home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 February: Tool Chest / Dev.CD Feb 94.toast / New System Software Extensions / QuickDraw™ GX v1.0ß2 / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ / UniversalMessageIntf.c < prev    next >
Encoding:
Text File  |  1993-09-13  |  89.3 KB  |  2,953 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     UniversalMessageIntf.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which override the universal imaging 
  7.     messages that the ImageWriter LQ utilizes.
  8.         
  9.     9/13/93 - dmh - Modified for the b2 seed.
  10.     
  11. COPYRIGHT
  12.     Copyright Apple Computer, Inc. 1992
  13.     All rights reserved. 
  14.     
  15. INTERFACE ROUTINES:
  16.     SD_Initialize
  17.     SD_ShutDown
  18.     SD_JobFormatDialog
  19.     SD_JobFormatModeQuery
  20.     SD_OpenConnection
  21.     SD_StartSendPage
  22.     SD_RenderPage
  23.     SD_DefaultPrinter
  24.     SD_SetupImageData
  25.     SD_FetchTaggedData
  26.     SD_RasterPackageBitmap
  27.     SD_RasterLineFeed
  28.  
  29. -------------------------------------------------------------------------------- */
  30.  
  31. // Include the standard Mac header files 
  32. #include "MacIncludes.h"
  33.  
  34. // Include the new QuickDraw GX graphics header files 
  35. #include <graphics routines.h>
  36. #include <graphics libraries.h>
  37. #include <math routines.h>
  38. #include <qd library.h>
  39. #include <font library.h>
  40. #include <layout routines.h>
  41. #include <graphics libraries.h>
  42.  
  43. // Include the required Printing Manager header files 
  44. #include <PrintingManager.h>
  45. #include <PrintingMessages.h>
  46. #include <PrintingDrivers.h>
  47. #include <Collections.h>
  48. #include <Messages.h>
  49. #include <PrintingResTypes.h>
  50. #include <PrintingErrors.h>
  51. #include <PrintingLibraries.h>
  52.  
  53. #include <Exceptions.h>
  54.  
  55. // Include the internal driver constants and types used by this module 
  56. #include "Resources.h"
  57. #include "UniversalMessageIntf.h"
  58. #include "OldAPIMessageIntf.h"
  59. #include "DialogRoutines.h"
  60.  
  61.  
  62. /***************************************************************************************
  63. *                                                 CONSTANTS                                                         *
  64. ***************************************************************************************/                        
  65.  
  66. // ImageWriter LQ device commands
  67.  
  68. #define    kEscape                            (char) 27        // <Escape> character
  69. #define    kLineFeed                        (char) 10        // Line feed character
  70. #define    kDevStatusCommand                "\033?"            // <Escape>? - used to query the status of the printer
  71.  
  72. #define    kLowResGraphicsCommand        (char) 'G'        //    72 dpi graphics mode
  73. #define    kHighResGraphicsCommand        (char) 'C'        //    216 dpi graphics mode
  74.  
  75. #define    kLowResMarginsCommand        (char) 'F'        //    72 dpi margins command
  76. #define    kHighResMarginsCommand        (char) 'h'        //    216 dpi margins command
  77.  
  78. #define    kSetColorCommand                (char) 'K'        //    Command to select color
  79.  
  80.  
  81. // Constants used with the ScanLineRecord structure
  82.  
  83. #define    kScanLineHdrSize                15                    //    Size of the constant portion of the scan line structure
  84.  
  85.  
  86. /***************************************************************************************
  87. *                                                 TYPES                                                                 *
  88. ***************************************************************************************/                        
  89.  
  90. // ScanLineRecord -    Structure overlayed within a buffer to fill in the comands and data needed to
  91. //                            package one complete scan line.
  92. typedef struct
  93. {
  94.     char        cMarginsEscape;            // kEscape character
  95.     char        cMarginsCommand;            // Set Margins command character
  96.     char        cIndentDistance[4];        // Number of pixels to indent
  97.  
  98.     char        cColorEscape;                // kEscape character
  99.     char        cSetColorCommand;            // Set color command
  100.     char        cColor;                        // The color to use
  101.  
  102.     char        cEscape;                        // kEscape character
  103.     char        cCommand;                    // Enter graphics mode command
  104.     char        cLineLength[4];            // number of dots to print
  105.     char        iTheData[9072];            // Bits for the data, enough for one line's worth
  106. }    ScanLineRecord,
  107.     *ScanLinePtr;
  108.  
  109.  
  110. /***************************************************************************************
  111. *                                         INTERNAL ROUTINES                                                     *
  112. ***************************************************************************************/                        
  113.  
  114. /****************************************************************************************
  115.  
  116.                             Long2Dec
  117.                             
  118.     function:
  119.                 This routine converts a long integer into an ASCII string representing the
  120.                 numeric value.  If the number is less than four digits, then it's padded
  121.                 with leading zeros.
  122.                 
  123.     parameters:                
  124.                 theNumber            number to convert to a string
  125.                 emitStringHere        location in which to store the ASCII string
  126.                 
  127.     returns:
  128.                 none
  129.     
  130. ****************************************************************************************/
  131. void Long2Dec(long theNumber, Ptr emitStringHere)
  132. {    
  133.     char        aString[10];
  134.     short        i;
  135.     short        actualWidth;
  136.     short        strLength;
  137.     
  138.     NumToString(theNumber, aString);
  139.     
  140.     // Get the width of the string, check for being too small
  141.  
  142.     strLength = Length(aString);
  143.     actualWidth = strLength;
  144.     if (actualWidth < 4)
  145.         actualWidth = 4;
  146.         
  147.     // output the string, padding with leading zeros
  148.     
  149.     strLength = actualWidth - strLength;
  150.     for (i = 0; i < actualWidth; ++i)
  151.     {
  152.         *emitStringHere++ = (i < strLength) ? '0' : aString[(i + 1) - strLength];
  153.     }
  154. }
  155. /* Long2Dec */
  156.  
  157.  
  158. /****************************************************************************************
  159.  
  160.                             PrinterHasColorRibbon
  161.                             
  162.     function:
  163.                 This routine is a utility function that returns true if the desktop printer
  164.                 configuration file specifies that the printer contains a color ribbon, and
  165.                 false if it has a black and white ribbon.
  166.                 
  167.     parameters:                
  168.                 None
  169.                 
  170.     returns:
  171.                 Boolean        true => printer has color ribbon; false => black and white ribbon
  172.     
  173. ****************************************************************************************/
  174. Boolean PrinterHasColorRibbon(void)
  175. {
  176.     OSErr                    anErr;
  177.     Boolean                    hasColor = true;
  178.     Str32                    deviceName;
  179.     IWLQConfigInfoHdl        configData;
  180.     
  181.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  182.  
  183.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  184.     if ( Length(deviceName) > 0 )
  185.     {
  186.         // if we are going to a particular device, assume no color, as that is more common
  187.         hasColor = false;
  188.         
  189.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  190.         if (anErr == noErr)
  191.         {
  192.             hasColor = (*configData)->hasColorRibbon;
  193.             DisposHandle((Handle) configData);
  194.         }
  195.     }
  196.     
  197.     return(hasColor);
  198. }
  199. /* PrinterHasColorRibbon */
  200.  
  201.  
  202. /****************************************************************************************
  203.  
  204.                             PrinterHasTrays
  205.                             
  206.     function:
  207.                 This routine is a utility function that returns the number of sheet feeder trays
  208.                 that are attached to the desktop printer.  If no sheet feeder is attached, then 
  209.                 the function returns zero.
  210.                 
  211.     parameters:                
  212.                 None
  213.                 
  214.     returns:
  215.                 char        number of sheet feeder trays attached to the printer; zero if no sheet feeder
  216.     
  217. ****************************************************************************************/
  218. char PrinterHasTrays(void)
  219. {
  220.     OSErr                        anErr;
  221.     char                        numTrays = 0;    //    Assume no trays available (common case)
  222.     Str32                        deviceName;
  223.     IWLQConfigInfoHdl            configData;
  224.     
  225.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  226.  
  227.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  228.     if ( Length(deviceName) > 0 )
  229.     {
  230.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  231.         if (anErr == noErr)
  232.         {
  233.             numTrays = (*configData)->numTrays;
  234.             DisposHandle((Handle) configData);
  235.         }
  236.     }
  237.     
  238.     return(numTrays);
  239. }
  240. /* PrinterHasTrays */
  241.  
  242.  
  243. /****************************************************************************************
  244.  
  245.                             UpdateDTPConfigInfo
  246.                             
  247.     function:
  248.                 This routine is a utility function that queries the printer to determine its
  249.                 configuration (color ribbon, trays, etc.) and updates the config info. in the
  250.                 desktop printer file to reflect this new configuration.
  251.                 
  252.     parameters:                
  253.                 None
  254.                 
  255.     returns:
  256.                 OSErr        error code
  257.     
  258. ****************************************************************************************/
  259. OSErr UpdateDTPConfigInfo(void)
  260. {
  261.     OSErr                    anErr;
  262.     IWLQConfigInfoHdl        configData;
  263.     char                    statusString[9];
  264.     long                    statusLength;
  265.     Boolean                    wasSheetfeederAttached;
  266.     gxJob                    theJob = GXGetJob();
  267.         
  268.     // Determine if there was a sheetfeeder attached to the printer the last time we updated the config file
  269.     wasSheetfeederAttached = PrinterHasTrays() > 0;
  270.     
  271.     // Make a handle in which to store the config. info.
  272.     
  273.     configData = (IWLQConfigInfoHdl) NewHandleClear( sizeof(IWLQConfigInfo) );
  274.     anErr = MemError();
  275.     require(anErr == noErr, NewHandleClear);
  276.     
  277.     // Now query the printer
  278.     
  279.     statusLength = 9;
  280.     
  281.     anErr = Send_GXGetDeviceStatus(kDevStatusCommand, 2, statusString, &statusLength, "\p\n");
  282.     require(anErr == noErr, Send_GXGetDeviceStatus);
  283.     
  284.     // Scan the status string returned looking for the needed info.
  285.     
  286.     if ( (statusString[0] == 'L') && (statusString[1] == 'Q') )
  287.     {
  288.         Str32        deviceName;
  289.  
  290.         if ( statusString[3] == 'C' )    //    T => Has color ribbon
  291.         {
  292.             (*configData)->hasColorRibbon = true;
  293.         }
  294.         
  295.         if (  (statusString[3] == 'E') || 
  296.                 (statusString[3] == 'F')
  297.             )                                            //    T => Sheet feeder is installed
  298.         {
  299.             (*configData)->numTrays = statusString[4] - 0x30;
  300.         }
  301.         else
  302.         if (    (statusString[4] == 'E') ||
  303.                 (statusString[4] == 'F')
  304.             )                                            //    T => Sheet feeder is installed
  305.         {
  306.             (*configData)->numTrays = statusString[5] - 0x30;
  307.         }
  308.  
  309.         //    Update the config. file with the latest info. (our driver info.)
  310.         
  311.         GXGetPrinterName(GXGetJobOutputPrinter(theJob), deviceName);
  312.         anErr = GXWriteDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle) configData);
  313.         require(anErr == noErr, GXWriteDTPData);
  314.  
  315.         // If this is the first time we've detected a sheet feeder, then we must set the tray info. (in the config. file)
  316.         // for the sheet feeder trays.  If this isn't the first time we've detected a sheetfeeder, we'll just use
  317.         // the last sheetfeeder tray settings.
  318.         
  319.         if ( (!wasSheetfeederAttached) && ((*configData)->numTrays > 0) )    //    T => No sheetfeeder before; clear the tray info.
  320.         {
  321.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the default tray */
  322.         }
  323.         else if ( wasSheetfeederAttached && ((*configData)->numTrays == 0) )    //    T => Sheetfeeder before; clear the tray info.
  324.         {
  325.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the first tray, ignore the others */
  326.         }
  327.     }
  328.     // else - not an LQ printer so don't change the config file info.
  329.  
  330.     // Dump the confog. data handle
  331.     DisposHandle((Handle) configData);
  332.  
  333.     return(anErr);
  334.     
  335.     
  336. /******* Clean-up *******/
  337.  
  338. GXWriteDTPData:
  339. Send_GXGetDeviceStatus:
  340.     DisposHandle((Handle) configData);
  341.     
  342. NewHandleClear:
  343.     return(anErr);
  344. }
  345. /* UpdateDTPConfigInfo */
  346.  
  347.  
  348. /****************************************************************************************
  349.  
  350.                             FixRoundRectangle
  351.                             
  352.     function:
  353.                 This routine is a utility function which rounds the coordinate values within 
  354.                 the gxRectangle passed in.
  355.                 
  356.     parameters:                
  357.                 r            gxRectangle whose coordinates are to be rounded
  358.                 
  359.     returns:
  360.                 None
  361.     
  362. ****************************************************************************************/
  363. void FixRoundRectangle(gxRectangle *r)
  364. {
  365.     r->top         = ff(FixRound(r->top));
  366.     r->left         = ff(FixRound(r->left));
  367.     r->bottom     = ff(FixRound(r->bottom));
  368.     r->right     = ff(FixRound(r->right));
  369. }
  370. /* FixRoundRectangle */
  371.  
  372.  
  373. /****************************************************************************************
  374.  
  375.                             UpdatePaperFeed
  376.                             
  377.     function:
  378.                 This routine is a utility routine for updating the auto-feed setting of the
  379.                 job.
  380.                 
  381.                 NOTE: THIS UTILITY ROUTINE NEEDS TO BE MOVED TO THE PUBLIC INTERFACE SO WE
  382.                 DON'T NEED TO INCLUDE IT HERE IN THIS DRIVER.  IT CAME FROM DIALOGUTILITIES.C.
  383.                 
  384.     parameters:
  385.                 theJob        the Job whose auto-feed boolean is to be set
  386.                 autoFeedOn    true => switch job to auto-feed; false => switch to manual feed
  387.                 
  388.     returns:
  389.                 OSErr
  390.  
  391. ****************************************************************************************/
  392. OSErr UpdatePaperFeed(gxJob theJob, Boolean autoFeedOn)
  393. {
  394.     OSErr            anErr;
  395.     Collection    jobCollection = GXGetJobCollection(theJob);
  396.  
  397.     anErr = AddCollectionItem ( jobCollection,
  398.                                  gxPaperFeedTag,
  399.                                  gxPrintingTagID,
  400.                                  1,
  401.                                  &autoFeedOn);
  402.  
  403.     check(anErr == noErr);
  404.     return(anErr);
  405. }
  406. /* UpdatePaperFeed */
  407.  
  408.  
  409. /****************************************************************************************
  410.  
  411.                             RetrieveJobItem
  412.                             
  413.     function:
  414.                 NOTE: THIS UTILITY ROUTINE NEEDS TO BE MOVED TO THE PUBLIC INTERFACE SO WE
  415.                 DON'T NEED TO INCLUDE IT HERE IN THIS DRIVER.  IT CAME FROM DIALOGUTILITIES.C.
  416.  
  417.     parameters:                
  418.  
  419.     returns:
  420.  
  421. ****************************************************************************************/
  422. OSErr    RetrieveJobItem( gxJob theJob, CollectionTag tag, long id, void *theValue, long *itemSize )
  423. {
  424.     OSErr    anErr = noErr;
  425.     Collection    theCollection = GXGetJobCollection( theJob );
  426.  
  427.     anErr = GetCollectionItem (theCollection,
  428.                                 tag,
  429.                                 id,
  430.                                 itemSize,
  431.                                 theValue );
  432.  
  433.     return( anErr );
  434.  
  435. }
  436. /* RetrieveJobItem */
  437.  
  438.  
  439. /****************************************************************************************
  440.  
  441.                             RetrievePaperFeed
  442.                             
  443.     function:
  444.                 NOTE: THIS UTILITY ROUTINE NEEDS TO BE MOVED TO THE PUBLIC INTERFACE SO WE
  445.                 DON'T NEED TO INCLUDE IT HERE IN THIS DRIVER.  IT CAME FROM DIALOGUTILITIES.C.
  446.     
  447.     parameters:
  448.     
  449.     returns:
  450.  
  451. ****************************************************************************************/
  452. OSErr    RetrievePaperFeed(gxJob theJob, Boolean *autoFeedOn, Boolean *feedLocked)
  453. {
  454.     #pragma unused (feedLocked)
  455.     
  456.     long    paperFeedSize = 1;
  457.  
  458.     return( RetrieveJobItem(     theJob, 
  459.                                 gxPaperFeedTag, 
  460.                                 gxPrintingTagID, 
  461.                                 autoFeedOn, 
  462.                                 &paperFeedSize ) );
  463.  
  464. }
  465. /* RetrievePaperFeed */
  466.  
  467.  
  468. /****************************************************************************************
  469.  
  470.                             RetrieveManualFeedPaper
  471.                             
  472.     function:
  473.                 NOTE: THIS UTILITY ROUTINE NEEDS TO BE MOVED TO THE PUBLIC INTERFACE SO WE
  474.                 DON'T NEED TO INCLUDE IT HERE IN THIS DRIVER.  IT CAME FROM DIALOGUTILITIES.C.
  475.  
  476.     parameters:                
  477.  
  478.     returns:
  479.  
  480. ****************************************************************************************/
  481. OSErr RetrieveManualFeedPaper(gxJob theJob, gxManualFeedInfo **paperTypeNameList)
  482. {
  483.     OSErr        anErr;
  484.     Collection    jobCollection = GXGetJobCollection(theJob);
  485.     Size        ptrSize;
  486.     
  487.     anErr = GetCollectionItemInfo(jobCollection, gxManualFeedTag, gxPrintingTagID,
  488.                                   0, &ptrSize, 0);
  489.     
  490.     
  491.     if (anErr == noErr) {
  492.     
  493.         *paperTypeNameList = (gxManualFeedInfo *) NewPtrClear(ptrSize);
  494.         anErr = MemError();
  495.         nrequire( anErr, NewPtrClearFails );
  496.  
  497.         anErr = GetCollectionItem( jobCollection, 
  498.                                     gxManualFeedTag, 
  499.                                     gxPrintingTagID, 
  500.                                     NULL,
  501.                                     *paperTypeNameList); 
  502.         }
  503.  
  504. NewPtrClearFails:
  505.     return( anErr );
  506. }
  507. /* RetrieveManualFeedPaper */
  508.  
  509.  
  510. /****************************************************************************************
  511.  
  512.                             IsManualFeedPaperType
  513.                             
  514.     function:
  515.                 NOTE: THIS UTILITY ROUTINE NEEDS TO BE MOVED TO THE PUBLIC INTERFACE SO WE
  516.                 DON'T NEED TO INCLUDE IT HERE IN THIS DRIVER.  IT CAME FROM DIALOGUTILITIES.C.
  517.     
  518.     parameters:
  519.     
  520.     returns:
  521.  
  522. ****************************************************************************************/
  523. OSErr    IsManualFeedPaperType(gxPaperType thePaperType, Boolean *IsManualFeed)
  524. {
  525.     OSErr                anErr;
  526.     gxJob                theJob = GXGetJob();
  527.     Boolean                fAutoFeedOn;
  528.     gxManualFeedInfo    *paperTypeNameList = nil;
  529.     short                nameCount, idx;
  530.     Str31                paperName;
  531.  
  532.     *IsManualFeed    = false;
  533.     anErr = RetrievePaperFeed( theJob, &fAutoFeedOn, nil );
  534.     nrequire( anErr, RetrievePaperFeedFails );
  535.     
  536.     if ( !fAutoFeedOn ) {
  537.  
  538.         anErr = RetrieveManualFeedPaper( theJob, &paperTypeNameList );
  539.         
  540.         if (anErr == collectionItemNotFoundErr) {
  541.         
  542.             *IsManualFeed = true;
  543.             anErr = noErr;
  544.             
  545.         } else {
  546.         
  547.             nrequire( anErr, RetrieveManualFeedPaperFails );
  548.             
  549.             GXGetPaperTypeName( thePaperType, paperName );
  550.             nameCount = paperTypeNameList->numPaperTypeNames;
  551.             
  552.             for (idx = 0; idx < nameCount; ++idx) {
  553.  
  554.                 Ptr pName = &paperTypeNameList->paperTypeNames[idx];
  555.                 
  556.                 if ( IUMagIDString(    paperName, 
  557.                                     pName,
  558.                                     paperName[0] + 1,
  559.                                     *pName + 1)     == 0  ) {
  560.                     *IsManualFeed = true;
  561.                     break;
  562.                     }
  563.                 }
  564.             }
  565.         }
  566.  
  567.     
  568. RetrieveManualFeedPaperFails:
  569.  
  570.     if ( paperTypeNameList != nil )
  571.         DisposPtr( (Ptr) paperTypeNameList );
  572.         
  573. RetrievePaperFeedFails:
  574.  
  575.     return( anErr );
  576. }
  577. /* IsManualFeedPaperType */
  578.  
  579.  
  580. /****************************************************************************************
  581.  
  582.                             JobIsBestQuality
  583.                             
  584.     function:
  585.                 This routine is called to determine if the job the driver is currently
  586.                 processing is to be output in best quality or rough quality. The function
  587.                 returns true if best quality, and false otherwise.
  588.                 
  589.     parameters:    
  590.                 None
  591.                 
  592.     returns:
  593.                 Boolean        true if best quality job; false otherwise
  594.     
  595. ****************************************************************************************/
  596. Boolean JobIsBestQuality(void)
  597. {
  598.     OSErr                anErr;
  599.     Boolean                isFinal;
  600.     gxQualityInfo        jobQualitySettings;
  601.     long                itemSize = sizeof(jobQualitySettings);
  602.  
  603.     // Retrieve the quality setting info from the job
  604.     anErr = GetCollectionItem(GXGetJobCollection(GXGetJob()), gxQualityTag, gxPrintingTagID, &itemSize, &jobQualitySettings);
  605.     check(anErr == noErr);
  606.     
  607.     isFinal = (anErr == noErr) && (jobQualitySettings.currentQuality == 1);
  608.  
  609.     return(isFinal);
  610. }
  611. /* JobIsBestQuality */
  612.  
  613.  
  614. /****************************************************************************************
  615.  
  616.                             MakeNewPrinterViewDevice
  617.                             
  618.     function:
  619.                 This routine is called to add a new view device to the printer object.  The
  620.                 gxViewDevice that's added will have a resolution of 216 dpi, and will have the
  621.                 set of colors specified by the theColors parameter.  The newly created 
  622.                 view device is added to the printer object.
  623.                 
  624.     parameters:                
  625.                 thePrinter        the newly allocated printer object
  626.                 theColors        the colors over which the view device is defined
  627.                 numColrs            the number of colors in the set
  628.                 
  629.     returns:
  630.                 OSErr
  631.                 
  632. ****************************************************************************************/
  633. OSErr MakeNewPrinterViewDevice(    gxPrinter    thePrinter,
  634.                                 gxSetColor        theColors[],
  635.                                 short            numColors)
  636. {
  637.     OSErr             anErr = noErr;
  638.     gxViewDevice     vd;
  639.     gxMapping        vdMapping;
  640.     gxShape            theBitmap;
  641.     gxColorSet        theColorSet;
  642.     
  643.     // Create the new gxViewDevice using a fake gxBitmap 
  644.     {
  645.         gxBitmap    aBitmap;
  646.         
  647.         aBitmap.pixelSize    = 1;
  648.         aBitmap.rowBytes    = 0;
  649.         aBitmap.width        = 0;
  650.         aBitmap.height        = 0;
  651.         aBitmap.image        = nil;
  652.         aBitmap.space        = gxNoSpace;
  653.         aBitmap.set            = nil;
  654.         aBitmap.profile    = nil;
  655.         
  656.         theBitmap = GXNewBitmap(&aBitmap, nil);
  657.         require_action( GXGetGraphicsError(nil) == noErr, GXNewBitmap, anErr = GXGetGraphicsError(nil); );
  658.         
  659.         vd = GXNewViewDevice(gxScreenViewDevices, theBitmap);
  660.         require_action( GXGetGraphicsError(nil) == noErr, GXNewViewDevice, anErr = GXGetGraphicsError(nil); );
  661.  
  662.         // Dispose of the reference to the temporary gxShape
  663.         GXDisposeShape(theBitmap);
  664.     }
  665.     
  666.     // Now set the view device's color space based on the set of colors passed in 
  667.     {
  668.         theColorSet = GXNewColorSet(gxRGBSpace, numColors, theColors);
  669.         require_action( GXGetGraphicsError(nil) == noErr, GXNewColorSet, anErr = GXGetGraphicsError(nil); );
  670.  
  671.         SetViewDeviceColorSet(vd, theColorSet);
  672.         require_action( GXGetGraphicsError(nil) == noErr, SetViewDeviceColorSet, anErr = GXGetGraphicsError(nil); );
  673.     
  674.         // Dispose of the reference to the temporary gxShape
  675.         GXDisposeColorSet(theColorSet);
  676.     }
  677.     
  678.     // Change the gxViewDevice gxMapping to include the scaling factor from 72dpi (screen) to 216 dpi (device). 
  679.     {
  680.         ResetMapping(&vdMapping);
  681.         ScaleMapping(&vdMapping, ff(3), ff(3), ff(0), ff(0));
  682.         
  683.         GXSetViewDeviceMapping(vd, &vdMapping);
  684.     }
  685.     
  686.     // Add the newly created gxViewDevice to the printer object 
  687.  
  688.     anErr = GXAddPrinterViewDevice(thePrinter, vd);
  689.     require_action( GXGetGraphicsError(nil) == noErr, GXAddPrinterViewDevice, anErr = GXGetGraphicsError(nil); );
  690.     
  691.     return(anErr);
  692.     
  693.     
  694. /******* Clean-up *******/
  695.  
  696. SetViewDeviceColorSet:
  697.     GXDisposeColorSet(theColorSet);
  698.  
  699. GXAddPrinterViewDevice:
  700. GXNewColorSet:
  701.     GXDisposeViewDevice(vd);
  702.     return(anErr);
  703.  
  704. GXNewViewDevice:
  705.     GXDisposeShape(theBitmap);
  706.  
  707. GXNewBitmap:
  708.     return(anErr);
  709. }
  710. /* MakeNewPrinterViewDevice */
  711.  
  712.  
  713. /****************************************************************************************
  714.  
  715.                             WriteDraftChars
  716.                             
  717.     function:
  718.                 This routine is called to output a single character in the native set of the
  719.                 printer.  The draftTable parameter contains long word entries for each possible
  720.                 character that can be printed.  Each long word entry is composed of two word entries,
  721.                 where the first word represents the primary character to output and the second
  722.                 word optionally specifies an overstrike character.  If an overstrike character
  723.                 is specified, then we will overstrike the second character on the first.  The format
  724.                 of each word is the same and is as follows:
  725.                 
  726.                 bit 15         -    0 => don't backspace before writing character
  727.                                     1 => backspace first before printing the character
  728.                 
  729.                 bits 14:12    -    0
  730.  
  731.                 bits 11:8    -    national character set to invoke (e.g. kAmerican)
  732.  
  733.                 bits 7:0        -    the character to send to the printer (must be != 0 to be output)
  734.                 
  735.     parameters:    
  736.                 draftTable        Handle to an array of long word entries that describe how to output
  737.                                     each printable character in draft mode
  738.                 draftChar        Pointer to the ASCII characters that are to be output
  739.                 numChars            Number of characters to be output
  740.                 
  741.     returns:
  742.                 OSErr
  743.     
  744. ****************************************************************************************/
  745. OSErr WriteDraftChars(long **draftTable, unsigned char *draftChar, long numChars)
  746. {
  747.     OSErr        anErr = noErr;
  748.     char        outputChars[20];                // a maximum of 20 characters can be generated
  749.     short        charCount;                    
  750.     
  751.     // For each character in the buffer, determine how to map the character to a draft character
  752.     for (; numChars > 0; --numChars, ++draftChar)
  753.     {
  754.         // No characters yet for this output character
  755.         charCount = 0;
  756.             
  757.         // Only consider characters in the printable range
  758.         if (*draftChar >= 0x20)
  759.         {
  760.             unsigned long    draftControl = (*draftTable)[*draftChar-0x20];    // Fetch native mode long word corresponding to this character
  761.             unsigned char    outChar;
  762.             unsigned char    nationalSet;
  763.             short                i;
  764.             
  765.             // For each word which composes the native mode long word 
  766.             for (i = 1; i >= 0; --i)
  767.             {
  768.                 // Should we send a backspace character (to overstrike)?
  769.                 if ( (draftControl & 0x80000000) != 0 )
  770.                     outputChars[charCount++] = 0x08;
  771.                 
  772.                 outChar = (draftControl >> 16) & 0xFF;
  773.                 if (outChar != 0)
  774.                 {
  775.                     // Determine the national character set to select
  776.                     nationalSet = (draftControl >> 24) & 0xF;    
  777.     
  778.                     //    Is this character in the standard, built-in character set?
  779.                     if (nationalSet == kAmerican)
  780.                     {
  781.                         outputChars[charCount++] = outChar;
  782.                     }
  783.                     else    //    T => Must select a foreign language character set 
  784.                     {
  785.                         outputChars[charCount++] = 0x1B;
  786.                         outputChars[charCount++] = 0x44;
  787.                         outputChars[charCount++] = nationalSet;
  788.                         outputChars[charCount++] = 0x00;
  789.                         outputChars[charCount++] = outChar;
  790.                         outputChars[charCount++] = 0x1B;                // We always switch back to the kAmerican character set
  791.                         outputChars[charCount++] = 0x5A;
  792.                         outputChars[charCount++] = 0x07;
  793.                         outputChars[charCount++] = 0x00;
  794.                     }
  795.                 }
  796.                 
  797.                 // Take the next (low) word and process it (if we're not all done)
  798.                 draftControl <<= 16;
  799.             }    
  800.         }
  801.             
  802.         // If we generated any data, send it out now
  803.         if (charCount > 0)
  804.             anErr = Send_GXBufferData(outputChars, charCount, gxNoBufferOptions);
  805.     }
  806.         
  807.     return(anErr);    
  808.     
  809. } 
  810. /* WriteDraftChars */
  811.  
  812.  
  813. /****************************************************************************************
  814.  
  815.                             GetPointerThisBig
  816.                             
  817.     function:
  818.                 This routine is called to return a pointer (in the heap) to the number of
  819.                 bytes specified by numBytes.  If the pointer is already large enough, then
  820.                 this routine simply returns the existing pointer.  Otherwise, it allocates
  821.                 a new pointer (possibly disposing of the old one) of the specified size.
  822.                 
  823.     parameters:    
  824.                 theBuff            returns a pointer to the allocated buffer 
  825.                 numBytes            required size of the pointer returned (in bytes)
  826.                 
  827.     returns:
  828.                 OSErr
  829.     
  830. ****************************************************************************************/
  831. OSErr GetPointerThisBig(Ptr *theBuff, long numBytes) 
  832. {
  833.     OSErr        anErr = noErr;
  834.     
  835.     if (*theBuff != nil)
  836.     {
  837.         if ( GetPtrSize(*theBuff) < numBytes )    //    T => Won't be big enough; make a new one
  838.         {
  839.             DisposPtr(*theBuff);
  840.             *theBuff = nil;
  841.         }
  842.     }
  843.  
  844.     if (*theBuff == nil)
  845.     {
  846.         *theBuff = NewPtrClear(numBytes);
  847.         anErr = MemError();
  848.     }
  849.     
  850.     return(anErr);
  851. }
  852. /* GetPointerThisBig */
  853.  
  854.  
  855. /****************************************************************************************
  856.  
  857.                             GetTextAndPosition
  858.                             
  859.     function:
  860.                 This routine is called to return information about the layout gxShape
  861.                 referenced by the theShape parameter.  It returns a pointer to the
  862.                 text data in theChars, the number of characters in the data in numChars, and
  863.                 a pointer to the positions of the characters in textPositions.  The caller
  864.                 is responsible for disposing of the pointers returned in theChars and
  865.                 textPositions.
  866.                 
  867.     parameters:    
  868.                 theShape            reference to the gxShape to be examined
  869.                 theChars            returns a pointer to the text characters
  870.                 numChars            returns the number of characters in the text gxShape
  871.                 textPosition    returns the position of the layout gxShape
  872.                 
  873.     returns:
  874.                 OSErr
  875.     
  876. ****************************************************************************************/
  877. OSErr GetTextAndPosition(    gxShape            theShape, 
  878.                             Ptr            *theChars, 
  879.                             long            *numChars, 
  880.                             gxPoint            *textPosition)
  881. {
  882.     OSErr        anErr = noErr;
  883.     long        textLength;
  884.     
  885.     // Determine the size of the text data and the position of the text
  886.     textLength = GXGetLayout(theShape, nil, nil, nil, nil, nil, nil, nil, nil, textPosition);
  887.  
  888.     // Make sure we have a buffer pointer large enough to hold all of the data
  889.     
  890.     anErr = GetPointerThisBig(theChars, textLength);
  891.     require(anErr == noErr, CantAllocTextBuff);
  892.     
  893.     // Now we retrieve the text
  894.     GXGetLayout(theShape, *theChars, nil, nil, nil, nil, nil, nil, nil, nil);
  895.     
  896.     // Remember the number of characters in the gxShape
  897.     *numChars = textLength;
  898.     
  899.  
  900. /******* Clean-up *******/
  901.  
  902. CantAllocTextBuff:
  903.     return(anErr);
  904. }
  905. /* GetTextAndPosition */
  906.  
  907.  
  908. /****************************************************************************************
  909.  
  910.                             PrintPageInDraftMode
  911.                             
  912.     function:
  913.                 This routine is called to print a page using the native character set in the
  914.                 printer.  The page to print is referenced by the thePage parameter.  The routine
  915.                 walks through the picture looking for layout gxShapes.  Each of these
  916.                 gxShapes is imaged using the native character set; all other gxShapes are ignored.
  917.                 This routine assumes the gxShapes within the picture are y-sorted.
  918.                 
  919.     parameters:    
  920.                 thePage        Reference to the page gxShape that's to be printed
  921.                 imageData    pointer to the raster image data
  922.                 
  923.     returns:
  924.                 OSErr
  925.     
  926. ****************************************************************************************/
  927. OSErr PrintPageInDraftMode(gxShape thePage, gxRasterImageDataHdl imageData)
  928. {
  929.     OSErr                    anErr = noErr;
  930.     long                    i;
  931.     long                    numItems;
  932.     Fixed                    currYPos = ff(0);
  933.     Ptr                        theChars = nil;
  934.     long                    numChars = 0;
  935.     gxPoint                    textPosition;
  936.     Fixed                    oldTextSize = ff(0);
  937.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  938.     
  939.     // Since the page picture we need to process is a picture gxShape that's embedded in
  940.     // thePage (a gxShape containing one item => a picture), we need to extract the real
  941.     // page picture from thePage.
  942.     
  943.     thePage = GetPictureItem(thePage, 1, nil, nil, nil, nil);
  944.     numItems = GXGetPicture(thePage, nil, nil, nil, nil);
  945.     
  946.     // For each gxShape within the picture, check its type and process it accordingly
  947.     
  948.     for (i = 1; i <= numItems; ++i)
  949.     {
  950.         gxShape                theShape;
  951.         short                theType;
  952.         
  953.         theShape = GetPictureItem(thePage, i, nil, nil, nil, nil);
  954.         theType = GXGetShapeType(theShape);
  955.         
  956.         if (theType == gxLayoutType)    //    T => We have a layout gxShape
  957.         {
  958.             fixed        textSize;
  959.             char        buff[12];
  960.             char        theFace;
  961.             short        cmndBuffSz;
  962.             
  963.             // First determine the gxStyle in which we're printing
  964.             
  965.             theFace = GetStyleCommonFace( GXGetShapeStyle(theShape) );
  966.             
  967.             buff[0] = kEscape;
  968.             if ( (theFace & bold) != 0 )    //    T => Turn bold facing on
  969.                 buff[1] = '!';
  970.             else                                    //    T => Turn it off
  971.                 buff[1] = '"';
  972.             
  973.             buff[2] = kEscape;
  974.             if ( (theFace & underline) != 0 )    //    T => Turn underline facing on
  975.                 buff[3] = 'X';
  976.             else                                            //    T => Turn it off
  977.                 buff[3] = 'Y';
  978.                 
  979.             cmndBuffSz = 4;
  980.             
  981.             // Next determine if we need to change the size of the gxFont being used
  982.             
  983.             textSize = GXGetShapeTextSize(theShape);
  984.             if (textSize != oldTextSize)    //    T => Must issue LQ command to change gxFont size
  985.             {
  986.                 buff[4] = kEscape;                //    The first escape command selects black color
  987.                 buff[5] = kSetColorCommand;
  988.                 buff[6] = '0';
  989.                 
  990.                 buff[7] = kEscape;                //    The second escape command selects a draft gxFont
  991.                 buff[8] = 'a';
  992.                 buff[9] = '1';
  993.                 
  994.                 buff[10] = kEscape;                //    The third escape command selects the character pitch
  995.                 
  996.                 if ( textSize <= ff(10) )    //    T => Select 10 cpi
  997.                 {
  998.                     buff[11] = 'N';
  999.                 }
  1000.                 else    //    T => All other sizes get mapped to 12 cpi
  1001.                 {
  1002.                     buff[11] = 'E';
  1003.                 }
  1004.                 
  1005.                 // Remember the last text size
  1006.                 oldTextSize = textSize;    
  1007.                 
  1008.                 // Adjust the size of the data to be sent to the printer
  1009.                 cmndBuffSz += 8;
  1010.             }
  1011.             // else - no change in gxFont size
  1012.             
  1013.             // Send the commands to the printer
  1014.             anErr = Send_GXBufferData(buff, cmndBuffSz, gxDontSplitBuffer);
  1015.             require(anErr == noErr, CantSendFontCmnd);
  1016.  
  1017.             // Get the ASCII text and the starting position of the data
  1018.             anErr = GetTextAndPosition(theShape, &theChars, &numChars, &textPosition);
  1019.             require(anErr == noErr, CantGetTextAndPos);
  1020.             
  1021.             if ( (currYPos != ff(0)) && (currYPos != textPosition.y) )    //    T => Moving to a lower line, finish the last ;line with a CR
  1022.             {
  1023.                 char        c = 0x0D;
  1024.                 
  1025.                 anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  1026.                 require(anErr == noErr, CantSendCRCmnd);
  1027.             }
  1028.             
  1029.             // Position the print head to the proper location on the page
  1030.             {
  1031.                 gxMapping            theMapping;
  1032.                 short                lineFeedSize;
  1033.                 Str255                positionCmndsBuff;
  1034.                 unsigned long        bytesInBuff = 0;
  1035.                 char                *p;
  1036.  
  1037.                 GXGetShapeMapping(theShape, &theMapping);
  1038.                 MapPoints(&theMapping, (long) 1, &textPosition);    //    Just map the first gxPoint
  1039.                 
  1040.                 // Now position the print head vertically
  1041.  
  1042.                 lineFeedSize = (textPosition.y - currYPos) >> 16;
  1043.                 anErr = Send_GXRasterLineFeed(&lineFeedSize, positionCmndsBuff, &bytesInBuff, imageData);
  1044.                 require(anErr == noErr, CantEmitLineFeeds);
  1045.                 
  1046.                 // Update the current Y position pointer on the page
  1047.                 currYPos = textPosition.y;
  1048.  
  1049.                 // Now position the print head horizontally on the page
  1050.  
  1051.                 p = &positionCmndsBuff[bytesInBuff];        
  1052.                 *p++ = kEscape;
  1053.                 *p++ = kLowResMarginsCommand;
  1054.                 Long2Dec((*hGlobals)->leftMargin + FixedToInt(textPosition.x), p);    // Convert left margin into ASCII and place it at the start of the scan line
  1055.                 
  1056.                 // Update the number of bytes in the buffer
  1057.                 bytesInBuff += 6;
  1058.  
  1059.                 // Send the positioning info to the printer
  1060.                 anErr = Send_GXBufferData(positionCmndsBuff, bytesInBuff, gxDontSplitBuffer);
  1061.                 require(anErr == noErr, CantSendPositionCmnds);
  1062.             }
  1063.             
  1064.             // Now we send the text data to the printer
  1065.             anErr = WriteDraftChars((long **) (*hGlobals)->draftTable, theChars, numChars);
  1066.             require(anErr == noErr, CantWriteChars);
  1067.         }
  1068.     }    // for
  1069.  
  1070.     // Send one last CR to wrap the last line (if there was one)
  1071.     {
  1072.         char        c = 0x0D;
  1073.         
  1074.         anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  1075.     }
  1076.  
  1077.  
  1078. /******* Clean-up *******/
  1079.  
  1080. CantWriteChars:
  1081. CantSendPositionCmnds:
  1082. CantEmitLineFeeds:
  1083. CantSendCRCmnd:
  1084. CantGetTextAndPos:
  1085. CantSendFontCmnd:
  1086.     if (theChars != nil)
  1087.         DisposPtr(theChars);
  1088.                 
  1089.     return(anErr);
  1090. }
  1091. /* PrintPageInDraftMode */
  1092.  
  1093.  
  1094. /***************************************************************************************
  1095. *                                         INTERFACE ROUTINES                                                     *
  1096. ***************************************************************************************/                        
  1097.  
  1098. /****************************************************************************************
  1099.  
  1100.                             SD_Initialize
  1101.                             
  1102.     function:
  1103.                 This routine is called when a new job is created to perform some job-oriented
  1104.                 task, such as conducting dialogs, spooling, and imaging.  It allocates the
  1105.                 driver's globals handle and initializes it.
  1106.                 
  1107.     parameters:    
  1108.                 None
  1109.                 
  1110.     returns:
  1111.                 OSErr
  1112.     
  1113. ****************************************************************************************/
  1114. OSErr SD_Initialize(void)
  1115. {
  1116.     OSErr                 anErr;
  1117.     SpecGlobalsHdl     hGlobals;
  1118.     
  1119.     // Allocate the driver's global handle 
  1120.  
  1121.     hGlobals = (SpecGlobalsHdl) NewHandleClear(kSpecGlobalsRecLen);
  1122.     anErr = MemError();
  1123.     require(anErr == noErr, NewHandleClear);
  1124.     
  1125.     // Tell the Printing Manager to save our globals handle for us 
  1126.     SetMessageHandlerInstanceContext(hGlobals);
  1127.  
  1128.     return(anErr);
  1129.     
  1130.     
  1131. /******* Clean-up *******/
  1132.  
  1133. NewHandleClear:
  1134.     return(anErr);
  1135. }
  1136. /* SD_Initialize */
  1137.  
  1138.  
  1139. /****************************************************************************************
  1140.  
  1141.                             SD_ShutDown
  1142.                             
  1143.     function:
  1144.                 This routine is called when a job-oriented task has completed and the 
  1145.                 message chain is being destroyed.  This routine disposes of the driver's
  1146.                 globals handle..
  1147.                 
  1148.     parameters:        
  1149.                 None
  1150.                 
  1151.     returns:
  1152.                 OSErr
  1153.     
  1154. ****************************************************************************************/
  1155. OSErr SD_ShutDown(void)
  1156. {
  1157.     SpecGlobalsHdl hGlobals = GetMessageHandlerInstanceContext();
  1158.     
  1159.     // Dump the draft table if we loaded it
  1160.     if ( (*hGlobals)->draftTable != nil )
  1161.         DisposHandle((*hGlobals)->draftTable);
  1162.     
  1163.     // Dump the driver's globals handle if it was allocated 
  1164.     if (hGlobals != nil)
  1165.         DisposHandle((Handle) hGlobals);
  1166.  
  1167.     // Make sure the Printing Manager no longer has a reference to our globals handle 
  1168.     SetMessageHandlerInstanceContext(nil);
  1169.         
  1170.     return(noErr);
  1171. }
  1172. /* SD_ShutDown */
  1173.  
  1174.  
  1175. /****************************************************************************************
  1176.  
  1177.                             SD_JobFormatDialog
  1178.                             
  1179.     function:
  1180.                 This routine is called when the Printing Manager is called to display the
  1181.                 Job gxFormat dialog.  This message gives the driver the opportunity to determine
  1182.                 the job format modes that are supported by the application.  If the application
  1183.                 supports text, then we set the preferred job format mode to be 'text'.  The preferred
  1184.                 format mode is the format mode that becomes active when the user selects Direct
  1185.                 Mode from the Job gxFormat dialog box.
  1186.                 
  1187.     parameters:                
  1188.                 dlgResult        result of dismissing the dialog (ok or cancel)
  1189.                 
  1190.     returns:
  1191.                 OSErr
  1192.                 
  1193. ****************************************************************************************/
  1194. OSErr SD_JobFormatDialog(gxDialogResult *dlgResult)
  1195. {
  1196.     OSErr                     anErr;
  1197.     gxJobFormatModeTableHdl    theJobFormatModeList;
  1198.     gxJob                     theJob = GXGetJob();
  1199.     
  1200.     // Did the application specify any job format modes?
  1201.     
  1202.     anErr = GXGetAvailableJobFormatModes(&theJobFormatModeList);
  1203.     if ( (anErr == noErr) && (theJobFormatModeList != nil) )
  1204.     {
  1205.         long    i;
  1206.  
  1207.         // Examine each job format mode to determine if 'text' mode is supported.  If
  1208.         // it is, then we make it the preferred format mode for Direct Mode printing
  1209.         
  1210.         for (i = 0; i <= (*theJobFormatModeList)->numModes - 1; ++i) 
  1211.         {
  1212.             if ((*theJobFormatModeList)->modes[i] == gxTextJobFormatMode) 
  1213.             {
  1214.                 // Tell Printing Manger we support 'text' Direct Mode, but that we also
  1215.                 // support other modes.
  1216.                 
  1217.                 GXSetPreferredJobFormatMode(gxTextJobFormatMode, false);
  1218.                 break;
  1219.             }
  1220.         }
  1221.         
  1222.         // Dump the temporary handle we were issued
  1223.         DisposHandle((Handle)theJobFormatModeList);
  1224.     }
  1225.         
  1226.     // New we let the dialog be displayed. 
  1227.  
  1228.     anErr = Forward_GXJobDefaultFormatDialog(dlgResult);
  1229.     require(anErr == noErr, Forward_GXJobFormatDialog);
  1230.     
  1231.     return(anErr);
  1232.     
  1233.     
  1234. /******* Clean-up *******/
  1235.  
  1236. Forward_GXJobFormatDialog:
  1237.     return(anErr);
  1238. }
  1239. /* SD_JobFormatDialog */
  1240.  
  1241.  
  1242. /****************************************************************************************
  1243.  
  1244.                             SD_JobPrintDialog
  1245.                             
  1246.     function:
  1247.                 This routine is called when the Printing Manager is called to display the
  1248.                 Job dialog.  This message gives the driver the opportunity to add the LQ Options
  1249.                 panel to the dialog.  This panel provides the user the option to choose between
  1250.                 bidirectional and unidirectional printing.
  1251.                 
  1252.     parameters:                
  1253.                 dlgResult        result of dismissing the dialog (ok or cancel)
  1254.                 
  1255.     returns:
  1256.                 OSErr
  1257.                 
  1258. ****************************************************************************************/
  1259. OSErr SD_JobPrintDialog(gxDialogResult *dlgResult)
  1260. {
  1261.     OSErr                     anErr;
  1262.     gxPanelSetupRecord        thePanelInfo;
  1263.     long                    headMotionSize;
  1264.     Collection                jobCollection;
  1265.     HeadMotionJobItem        theMotion;
  1266.         
  1267.     // Get a reference to the job's collection
  1268.     jobCollection = GXGetJobCollection( GXGetJob() );
  1269.     
  1270.     // See if the head motion collection item exists.  It the item already exists, then
  1271.     // we'll use the last settings.
  1272.  
  1273.     headMotionSize = sizeof(HeadMotionJobItem);
  1274.     anErr = GetCollectionItem (jobCollection,
  1275.                                         kDrvrCreatorType, 
  1276.                                         kHeadMotionItemIndex, 
  1277.                                            &headMotionSize,
  1278.                                            &theMotion);
  1279.                                         
  1280.     if (anErr == collectionItemNotFoundErr)    // T => Item doesn't exist; add it
  1281.     {
  1282.         theMotion.direction = doUnidirectional;
  1283.         
  1284.         anErr = AddCollectionItem(    GXGetJobCollection(GXGetJob()), 
  1285.                                     kDrvrCreatorType, 
  1286.                                     kHeadMotionItemIndex, 
  1287.                                     sizeof(HeadMotionJobItem),
  1288.                                     &theMotion);
  1289.         require(anErr == noErr, AddCollectionItem);
  1290.     }
  1291.     else
  1292.         require(anErr == noErr, CantGetCollection);
  1293.  
  1294.     // Before allowing the Printing Manager to display the dialog, we must first add
  1295.     // our panel to the dialog.  We do this by appropriately filling in the gxPanelSetupRecord
  1296.     // and then telling the Printing Manager to add our panel to the dialog.
  1297.     
  1298.     // Initialize the dialog panel structure
  1299.     thePanelInfo.panelResId            = kLQOptionsPanl;        //    Resource ID of the 'panl' resource
  1300.     thePanelInfo.resourceRefNum    = GXGetMessageHandlerResFile();
  1301.     thePanelInfo.refCon                = 0;
  1302.     thePanelInfo.panelKind            = gxDriverPanel;
  1303.     
  1304.     // Add the dialog panel to the Print dialog
  1305.     
  1306.     GXSetupDialogPanel(&thePanelInfo);
  1307.     anErr = GXGetJobError( GXGetJob() );
  1308.     require(anErr == noErr, SetupDialogPanel);
  1309.  
  1310.     // Now we let the dialog be displayed. 
  1311.  
  1312.     anErr = Forward_GXJobPrintDialog(dlgResult);
  1313.     check(anErr == noErr);
  1314.     
  1315.     
  1316. /******* Clean-up *******/
  1317.  
  1318. Forward_GXJobPrintDialog:
  1319. SetupDialogPanel:
  1320. CantGetCollection:
  1321. AddCollectionItem:
  1322.     return(anErr);
  1323. }
  1324. /* SD_JobPrintDialog */
  1325.  
  1326.  
  1327. /****************************************************************************************
  1328.  
  1329.                             SD_JobFormatModeQuery
  1330.                             
  1331.     function:
  1332.                 This routine is called when an application calls JobFormatModeQuery to determine
  1333.                 the format modes that are available from the driver.  This message gives the 
  1334.                 driver the opportunity to determine the type of format mode query the driver
  1335.                 is requesting and responds to it with the appropriate data.
  1336.                 
  1337.     parameters:                
  1338.                 theQuery        type of query to perform
  1339.                 srcData        source data (varies depending upon the type of query)
  1340.                 dstData        destination data (varies depending upon the type of query)
  1341.                 
  1342.     returns:
  1343.                 OSErr
  1344.                 
  1345. ****************************************************************************************/
  1346. OSErr SD_JobFormatModeQuery(gxQueryType theQuery, void *srcData, void *dstData)
  1347. {
  1348.     OSErr        anErr = noErr;
  1349.     Handle    theFonts;
  1350.     Handle    theStyles;
  1351.     
  1352.     check(dstData != nil);
  1353.     
  1354.     // What type of query is being requested?
  1355.     switch(theQuery) 
  1356.     {
  1357.         case gxSetStyleJobFormatCommonStyleQuery:
  1358.         {
  1359.             char                *pStyleName;
  1360.  
  1361.             // Fetch the list of supported styles
  1362.             
  1363.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1364.             require(anErr == noErr, FailedToLoadStyles1);
  1365.             
  1366.             HNoPurge(theStyles);
  1367.             HLock(theStyles);
  1368.             
  1369.             // Determine which style is being referenced and set the corresponding gxStyle (only 2 styles
  1370.             // are currently supported)
  1371.             
  1372.             if (**((short **) theStyles) == 2)    //    T => We have the correct number of styles
  1373.             {
  1374.                 char        whichFace = 0;
  1375.                 
  1376.                 pStyleName = ((char *) *theStyles) + sizeof(short); 
  1377.                 
  1378.                 if ( IUCompString(pStyleName, (char *) srcData) == 0 )    //    T => They want bold face
  1379.                 {
  1380.                     whichFace = bold;
  1381.                 }
  1382.                 else
  1383.                 {
  1384.                     // Point to the next name in the list
  1385.                     pStyleName += *pStyleName + 1;
  1386.  
  1387.                     if ( IUCompString(pStyleName, (char *) srcData) == 0 )    //    T => They want underline face
  1388.                     {
  1389.                         whichFace = underline;
  1390.                     }
  1391.                 }
  1392.  
  1393.                 //    If the client specified a valid face, set it now
  1394.                 if (whichFace != 0)
  1395.                 {
  1396.                     SetStyleCommonFace((gxStyle) dstData, GetStyleCommonFace((gxStyle) dstData) | whichFace);
  1397.                 }
  1398.             }
  1399.             // else - something is wrong with our resource
  1400.             
  1401.             // Dump the temporary handle
  1402.             DisposHandle(theStyles);
  1403.             
  1404.             break;
  1405.         }
  1406.             
  1407.         case gxGetJobFormatFontCommonStylesQuery:
  1408.         {
  1409.             short                numStyles;
  1410.             short                i;
  1411.             char                *pStyleName;
  1412.  
  1413.             // Fetch the list of supported styles
  1414.             
  1415.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1416.             require(anErr == noErr, FailedToLoadStyles2);
  1417.             
  1418.             HNoPurge(theStyles);
  1419.             HLock(theStyles);
  1420.             
  1421.             // Determine the number of styles in the list
  1422.             numStyles = **((short **) theStyles);
  1423.  
  1424.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the styles
  1425.                 SetHandleSize(*(Handle *)dstData, sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1426.             else
  1427.                 *(Handle *)dstData = NewHandle(sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1428.             
  1429.             anErr = MemError();
  1430.             require(anErr == noErr, StyleTableResizeFailed);
  1431.             
  1432.             // Now extract the name of each of the supported fonts
  1433.             
  1434.             for (i = 1, pStyleName = ((char *) *theStyles) + sizeof(short); i <= numStyles; ++i, pStyleName += *pStyleName + 1)
  1435.             {
  1436.                 BlockMove(pStyleName, (*((gxStyleNameTableHdl) *(Handle *)dstData))->styleNames[i - 1], *pStyleName + 1);
  1437.             }
  1438.             
  1439.             (*((gxStyleNameTableHdl) *(Handle *)dstData))->numStyleNames = numStyles;
  1440.             
  1441.             // Dump the temporary handle
  1442.             DisposHandle(theStyles);
  1443.             
  1444.             break;
  1445.         }
  1446.             
  1447.         case gxGetJobFormatLineConstraintQuery:            //    This type of query is not supported
  1448.             if (*(Handle *)dstData != nil)
  1449.                 SetHandleSize(*(Handle *)dstData, 0);        // Don't return any data
  1450.             break;
  1451.             
  1452.         case gxGetJobFormatFontsQuery:
  1453.         {
  1454.             short                numFonts;
  1455.             short                i;
  1456.             char                *pFontName;
  1457.  
  1458.             // Fetch the list of supported fonts
  1459.             
  1460.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeFontsID, &theFonts);
  1461.             require(anErr == noErr, FailedToLoadFonts);
  1462.             
  1463.             HNoPurge(theFonts);
  1464.             HLock(theFonts);
  1465.             
  1466.             // Determine the number of fonts in the list
  1467.             numFonts = **((short **) theFonts);
  1468.  
  1469.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the fonts
  1470.                 SetHandleSize(*(Handle *)dstData, sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1471.             else
  1472.                 *(Handle *)dstData = NewHandle(sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1473.             
  1474.             anErr = MemError();
  1475.             require(anErr == noErr, FontTableResizeFailed);
  1476.             
  1477.             // Now generate a reference to each of the supported fonts
  1478.             
  1479.             for (i = 1, pFontName = ((char *) *theFonts) + sizeof(short); i <= numFonts; ++i, pFontName += *pFontName + 1)
  1480.             {
  1481.                 gxFont        thisFont;
  1482.                 gxFontTable    *pFontTable;
  1483.             
  1484.                 thisFont = FindPNameFont(gxFullFontName, pFontName);
  1485.                 
  1486.                 pFontTable = *((gxFontTableHdl) *(Handle *)dstData);
  1487.                 pFontTable->fonts[i - 1] = thisFont;
  1488.             }
  1489.             
  1490.             (*((gxFontTableHdl) *(Handle *)dstData))->numFonts = numFonts;
  1491.             
  1492.             // Dump the temporary handle
  1493.             DisposHandle(theFonts);
  1494.  
  1495.             break;
  1496.         }
  1497.             
  1498.         case gxGetJobFormatFontConstraintQuery:
  1499.         {
  1500.             gxPositionConstraintTable        *pPositionTable;
  1501.             
  1502.             if ( *(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on position constraints
  1503.                 SetHandleSize(*(Handle *)dstData, sizeof(gxPositionConstraintTable) + sizeof(Fixed));
  1504.             else
  1505.                 *(Handle *)dstData = NewHandle( sizeof(gxPositionConstraintTable) + sizeof(Fixed) );
  1506.             
  1507.             pPositionTable = *((gxPositionConstraintTableHdl) *(Handle *)dstData);
  1508.             
  1509.             pPositionTable->phase.x     = 0;                //    Start at the top left corner of the page
  1510.             pPositionTable->phase.y     = 0;
  1511.             pPositionTable->offset.x     = ff(12);        // Indent from the top left by a six lines per inch margin
  1512.             pPositionTable->offset.y     = ff(12);         
  1513.             pPositionTable->numSizes     = 2;                // Two gxFont sizes supported
  1514.             pPositionTable->sizes[0]     = ff(10);         // 10 pitch
  1515.             pPositionTable->sizes[1]     = ff(12);         // 12 pitch
  1516.             
  1517.             break;
  1518.         }
  1519.     } // switch
  1520.     
  1521.     return(anErr);
  1522.     
  1523.  
  1524. /******* Clean-up *******/
  1525.  
  1526. StyleTableResizeFailed:
  1527.     DisposHandle((Handle) theStyles);
  1528.     return(anErr);
  1529.  
  1530. FontTableResizeFailed:
  1531.     DisposHandle((Handle) theFonts);
  1532.  
  1533. FailedToLoadStyles1:
  1534. FailedToLoadStyles2:
  1535. FailedToLoadFonts:
  1536.     return(anErr);
  1537. }
  1538. /* SD_JobFormatModeQuery */
  1539.  
  1540.  
  1541. /****************************************************************************************
  1542.  
  1543.                             SD_OpenConnection
  1544.                             
  1545.     function:
  1546.                 This routine is called when the Printing Manager sends the OpenConnection
  1547.                 message.  We take this opportunity to open a connection to the printer and
  1548.                 query the printer to determine its configuration (e.g. color ribbon, trays, etc.).
  1549.                 We then save the configuration information in the desktop printer file.
  1550.                 
  1551.     parameters:        
  1552.                 None
  1553.                 
  1554.     returns:
  1555.                 OSErr
  1556.     
  1557. ****************************************************************************************/
  1558. OSErr SD_OpenConnection(void)
  1559. {
  1560.     OSErr                anErr;
  1561.  
  1562.     // Try to open the connection
  1563.     
  1564.     anErr = Forward_GXOpenConnection();
  1565.     require(anErr == noErr, Forward_GXOpenConnection);
  1566.     
  1567.     // Query the printer so we can update the configuration information
  1568.     
  1569.     anErr = UpdateDTPConfigInfo();
  1570.     require(anErr == noErr, UpdateDTPConfigInfo);
  1571.     
  1572.     return(anErr);
  1573.     
  1574.     
  1575. /******* Clean-up *******/
  1576.  
  1577. UpdateDTPConfigInfo:
  1578.     Send_GXCleanupOpenConnection();
  1579.     
  1580. Forward_GXOpenConnection:
  1581.     return(anErr);
  1582. }
  1583. /* SD_OpenConnection */
  1584.  
  1585.  
  1586. /****************************************************************************************
  1587.  
  1588.                             SD_CleanupOpenConnection
  1589.                             
  1590.     function:
  1591.                 This routine is called when the Printing Manager sends the CleanupOpenConnection
  1592.                 message.  It's initiated by our SD_OpenConnection routine when we cannot query
  1593.                 the printer after opening the connection.  We simply forward the message along to
  1594.                 allow others in the message chain to cleanup.
  1595.                 
  1596.     parameters:        
  1597.                 None
  1598.                 
  1599.     returns:
  1600.                 OSErr
  1601.     
  1602. ****************************************************************************************/
  1603. void SD_CleanupOpenConnection(void)
  1604. {
  1605.     // Just forward along the message
  1606.     Forward_GXCleanupOpenConnection();
  1607. }
  1608. /* SD_CleanupOpenConnection */
  1609.  
  1610.  
  1611. /****************************************************************************************
  1612.  
  1613.                             SD_StartSendPage
  1614.                             
  1615.     function:
  1616.                 This routine is called by the Printing Manager to signal the start of sending
  1617.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1618.                 to make sure the paper is in the printer.  If the printer has trays attached,
  1619.                 then this routine determines from which tray to feed the paper and then sends
  1620.                 the appropriate tray selection command to the printer.  The tray to pull the
  1621.                 paper from has already been determined by this time by the Universal Driver.
  1622.                 The Job collection contains the index of the tray to pull from.
  1623.                 
  1624.     parameters:                
  1625.                 pageFormat        format for the page to print
  1626.  
  1627.     returns:
  1628.                 OSErr
  1629.     
  1630. ****************************************************************************************/
  1631. OSErr SD_StartSendPage (gxFormat pageFormat)
  1632. {
  1633.     OSErr                anErr;
  1634.     Boolean                manualFeed;
  1635.     gxPaperType            thePaperType;
  1636.     gxStatusRecord        *pStatus;
  1637.     SpecGlobalsHdl         hGlobals = GetMessageHandlerInstanceContext();
  1638.     
  1639.     // Determine if this is a manual feed job 
  1640.  
  1641.     thePaperType = GXGetFormatPaperType(pageFormat);
  1642.     anErr = IsManualFeedPaperType(thePaperType, &manualFeed);
  1643.     require(anErr == noErr, IsManualFeedPaperType);
  1644.     
  1645.     if (manualFeed)    //    T => Alert the user to place the paper into the printer
  1646.     {
  1647.         gxManualFeedRecord    *mfeedInfo;
  1648.  
  1649.         // Wait for all IO to complete, so that we can correctly tell the user what to do.
  1650.         // Since the WriteData message makes sure all data is flushed before performing the
  1651.         // IO, this call insures that pending IO is complete.
  1652.  
  1653.         anErr = Send_GXWriteData(nil, 0);
  1654.         nrequire(anErr, FlushAllData);
  1655.  
  1656.         // Now we set-up to alert the user to put paper into the printer
  1657.     
  1658.         pStatus = (gxStatusRecord *) NewPtrClear(sizeof(gxStatusRecord) + sizeof(gxManualFeedRecord));
  1659.         anErr = MemError();
  1660.         require(anErr == noErr, NewPtrClear);
  1661.     
  1662.         // Initialize the appropriate fields within the status record 
  1663.         
  1664.         pStatus->statResId         = gxUnivAlertStatusResourceId;
  1665.         pStatus->statResIndex     = gxUnivManualFeedIndex;
  1666.         pStatus->bufferLen         = sizeof(gxManualFeedRecord);
  1667.  
  1668.         mfeedInfo = (gxManualFeedRecord *) &pStatus->statusBuffer;
  1669.         mfeedInfo->canAutoFeed = true;
  1670.         GXGetPaperTypeName(thePaperType, mfeedInfo->paperTypeName);
  1671.  
  1672.         // Now display the alert to the user. Continue alerting until the user clicks OK, he cancels
  1673.         // printing, or some other fatal error happens
  1674.         do
  1675.         {
  1676.             // Issue the alert to the user
  1677.             anErr = GXAlertTheUser(pStatus);
  1678.         }
  1679.         while ( (anErr == noErr) && (pStatus->dialogResult == nil) );
  1680.         
  1681.         // Based upon the users response, we continue, cancel, or switch to auto-feed
  1682.         
  1683.         switch (pStatus->dialogResult)
  1684.         {
  1685.             case ok:                        // Assume the user loaded the paper 
  1686.                 break;
  1687.                 
  1688.             case cancel:                // User cancelled the job; make sure the error code is set
  1689.                 anErr = gxPrUserAbortErr;
  1690.                 break;
  1691.                 
  1692.             case gxAutoFeedButtonId:    // User wishes to do the remainder of the job with auto-feed. Update job to 
  1693.                                             // reflect auto-feed. 
  1694.                 
  1695.                 (void) UpdatePaperFeed(GXGetJob(), true);
  1696.                 break;
  1697.         }
  1698.         
  1699.         // Dump the status record
  1700.         DisposPtr((Ptr) pStatus);
  1701.     }
  1702.     
  1703.     require(anErr == noErr, UserAborted);
  1704.     
  1705.     // At this point we determine if there are trays attached, and if so, we need
  1706.     // to issue a command to the printer to select from the proper tray.
  1707.     
  1708.     if ( PrinterHasTrays() > 0 )    //    T => gxPrinter does have trays attached
  1709.     {
  1710.         gxTrayIndex                    whichTray;
  1711.         long                        itemSize;
  1712.         char                        cmndBuff[3];
  1713.         TraySettingsJobItem            oldAppTraySettings;
  1714.         
  1715.         // We first determine if we're printing from an old application or a new application because
  1716.         // the setting of which tray to use will be determined from different information. To see if
  1717.         // we are printing an old app. document, we look for the kTraySettingsItemIndex collection item.
  1718.         
  1719.         itemSize = sizeof(TraySettingsJobItem);
  1720.         if ( GetCollectionItem( GXGetJobCollection(GXGetJob()), kDrvrCreatorType, kTraySettingsItemIndex, &itemSize, &oldAppTraySettings) == noErr )
  1721.         {
  1722.             if ( (*hGlobals)->pagePrinting == 1 )    //    T => Printing the first page
  1723.             {
  1724.                 whichTray = oldAppTraySettings.firstPageFromTray - 1;        //    Must be zero based
  1725.             }
  1726.             else    //    T => Printing some other page
  1727.             {
  1728.                 whichTray = oldAppTraySettings.remainingFromTray - 1;        //    Must be zero based
  1729.             }
  1730.         }
  1731.         else    //    T => New app so get tray settings from the 'tray' collection item
  1732.         {
  1733.             // The 'tray' collection item within the job collection specifies which tray to select
  1734.             // the paper from.
  1735.             
  1736.             itemSize = sizeof(gxTrayIndex);
  1737.             if ( GetCollectionItem( GXGetJobCollection(GXGetJob()), gxTrayFeedTag, gxPrintingTagID, &itemSize, &whichTray) != noErr )
  1738.                 whichTray = 0;        // Use default tray if we can't get the collection item
  1739.             else
  1740.                 whichTray -= 1;        // Must be zero based
  1741.         }
  1742.         
  1743.         // Compose the tray selection command
  1744.         
  1745.         cmndBuff[0] = kEscape;
  1746.         cmndBuff[1] = '@';
  1747.         cmndBuff[2] = whichTray + 0x30;        // Force to an ACSII number
  1748.         
  1749.         // Send the command to the printer
  1750.         anErr = Send_GXBufferData(cmndBuff, 3, gxNoBufferOptions);
  1751.         require(anErr == noErr, BufferData);        
  1752.     }
  1753.     
  1754.     // Update the status information to tell the user that we're sending data to the printer
  1755.     
  1756.     anErr = GXReportStatus(kDriverStatusID, kSendingPartOfPageStatIdx);
  1757.     require(anErr == noErr, GXReportStatus);
  1758.  
  1759.     // Now forward the message to others in the chain
  1760.     
  1761.     anErr = Forward_GXStartSendPage(pageFormat);
  1762.     check(anErr == noErr);
  1763.     
  1764.     
  1765. /******* Cleanup *******/
  1766.  
  1767. GXReportStatus:
  1768. BufferData:
  1769. UserAborted:
  1770. NewPtrClear:
  1771. FlushAllData:
  1772. IsManualFeedPaperType:
  1773.     return(anErr);
  1774. }
  1775. /* SD_StartSendPage */
  1776.  
  1777.  
  1778. /****************************************************************************************
  1779.  
  1780.                             SD_ImagePage
  1781.                             
  1782.     function:
  1783.                 This routine is called by the Printing Manager to signal the start of imaging
  1784.                 a new page to the printer.  We take this opportunity to remember which page is
  1785.                 being printed.  This inforamtion is later used by SD_StartSendPage to control
  1786.                 the input tray selection for documents which are printed from old applications.
  1787.                 
  1788.     parameters:                
  1789.                 theFormat        format for the page being rendered
  1790.                 theShape            gxShape representing the page
  1791.                 pageInfo            information about the page being rendered
  1792.                 imageData        pointer to the raster image data
  1793.  
  1794.     returns:
  1795.                 OSErr
  1796.     
  1797. ****************************************************************************************/
  1798. OSErr SD_ImagePage (        gxSpoolFile                theFile, 
  1799.                             long                     pageNumber, 
  1800.                             gxFormat                theFormat, 
  1801.                             gxRasterImageDataHdl     imageData)
  1802. {
  1803.     OSErr                    anErr;
  1804.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1805.  
  1806.     // Remember which page of the document we're currently imaging
  1807.     (*hGlobals)->pagePrinting = pageNumber;
  1808.     
  1809.     // Send the message along to others in the chain
  1810.     anErr = Forward_GXImagePage(theFile, pageNumber, theFormat, imageData);
  1811.     check(anErr == noErr);
  1812.     
  1813.     return(anErr);
  1814. }
  1815. /* SD_ImagePage */
  1816.  
  1817.  
  1818. /****************************************************************************************
  1819.  
  1820.                             SD_RenderPage
  1821.                             
  1822.     function:
  1823.                 This routine is called by the Printing Manager to signal the start of sending
  1824.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1825.                 to make sure the paper is in the printer.  Next we set the printer's left margin
  1826.                 and then we're set to begin printing the page.
  1827.                 
  1828.     parameters:                
  1829.                 theFormat        format for the page being rendered
  1830.                 theShape            gxShape representing the page
  1831.                 pageInfo            information about the page being rendered
  1832.                 imageData        pointer to the raster image data
  1833.  
  1834.     returns:
  1835.                 OSErr
  1836.     
  1837. ****************************************************************************************/
  1838. OSErr SD_RenderPage (gxFormat                    theFormat, 
  1839.                     gxShape                        thePage, 
  1840.                     gxPageInfoRecord            *pageInfo, 
  1841.                     gxRasterImageDataHdl     imageData)
  1842. {
  1843.     OSErr                    anErr;
  1844.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1845.     gxRectangle            paperSize;
  1846.     
  1847.     // Find out how big our paper is
  1848.     GXGetFormatDimensions(theFormat, nil, &paperSize);
  1849.     
  1850.     // Determine the left margin (in pixels)
  1851.     {
  1852.         SpecGlobalsPtr            pGlobals;
  1853.         gxRasterImageDataPtr    pImageData;
  1854.  
  1855.         pImageData = *imageData;
  1856.         pGlobals = *hGlobals;
  1857.         if ( -(paperSize.left) < ff(18) )    // T => IW LQ's can't go tighter than .25 inch
  1858.             paperSize.left = -(ff(18));        
  1859.         
  1860.         pGlobals->leftMargin = FixedToInt( FixMul(-paperSize.left, FixDiv(pImageData->hImageRes, ff(72)) ) );
  1861.     }
  1862.  
  1863.     // If not text mode, image the page the normal raster way (via SD_RasterPackageBitmap).  We
  1864.     // must however set the size of the page and position the paper (with line feeds) to get to
  1865.     // the proper "top-of-form".
  1866.     
  1867.     if ( GXGetJobFormatMode(GXGetJob()) != gxTextJobFormatMode ) 
  1868.     {
  1869.         Str255            formLength;            // should be more than big enough for form skipping
  1870.         char                aNumber[8];
  1871.         char                len = 0;
  1872.         short                formLen;                // form length (in 144 dpi)
  1873.         short                i;
  1874.         
  1875.         // Force the current line position to be the top of form (assumes the user has positioned the 
  1876.         // paper properly by this time)
  1877.         
  1878.         formLength[len++] = kEscape;
  1879.         formLength[len++] = 'v';
  1880.  
  1881.         // Now we want to skip down the page past the top margin.  This will put us in a position to
  1882.         // output the first bands of data.
  1883.         
  1884.         formLen = FixedToInt( FixMul(-paperSize.top, ff(2)) );                    // length is set in 144 dpi
  1885.         if (formLen > 0)
  1886.         {
  1887.             // send multiples of 99 since this is the maximum line feed spacing we can have
  1888.             if (formLen >= 99)
  1889.             {
  1890.                 formLength[len++] = kEscape;
  1891.                 formLength[len++] = 'T';
  1892.                 formLength[len++] = '9';
  1893.                 formLength[len++] = '9';
  1894.                 do
  1895.                 {
  1896.                     formLength[len++] = kLineFeed;        // line feed
  1897.                     
  1898.                     formLen -= 99;
  1899.                 }
  1900.                 while (formLen >= 99);
  1901.             }
  1902.                 
  1903.             // Send remaining line feeds to position to the top of the printable page
  1904.             if (formLen > 0)
  1905.             {
  1906.                 formLength[len++] = kEscape;
  1907.                 formLength[len++] = 'T';
  1908.                 NumToString(formLen, aNumber);
  1909.                 if ( Length(aNumber) == 1 )
  1910.                 {
  1911.                     formLength[len++] = '0';
  1912.                     formLength[len++] = aNumber[1];
  1913.                 }
  1914.                 else
  1915.                 {
  1916.                     formLength[len++] = aNumber[1];
  1917.                     formLength[len++] = aNumber[2];
  1918.                 }
  1919.                 formLength[len++] = kLineFeed;        // line feed
  1920.             }
  1921.         }
  1922.         
  1923.         // Now we must specify the paper length based upon the paper size asociated with the format
  1924.         
  1925.         formLength[len++] = kEscape;
  1926.         formLength[len++] = 'H';
  1927.  
  1928.         formLen = FixedToInt( FixMul(paperSize.bottom - paperSize.top, ff(2)) );    // length is set in 144 dpi
  1929.         NumToString(formLen, aNumber);
  1930.         for (i = 0; i < 4-aNumber[0]; ++i)
  1931.             formLength[len++] = '0';
  1932.         for (i = 1; i <= aNumber[0]; ++i)
  1933.             formLength[len++] = aNumber[i];
  1934.  
  1935.         // Send out the line feeds and the paper size specifier
  1936.         anErr = Send_GXBufferData(&formLength[0], len, gxNoBufferOptions);
  1937.         require(anErr == noErr, SetFormLength);        
  1938.     
  1939.         // Now forward the message to others in the chain
  1940.         
  1941.         anErr = Forward_GXRenderPage(theFormat, thePage, pageInfo, imageData);
  1942.         require(anErr == noErr, Forward_GXRenderPage);
  1943.     } 
  1944.     else    //    T => Doing draft (i.e. direct mode) print job; we do all the rendering
  1945.     {
  1946.         anErr = PrintPageInDraftMode(thePage, imageData);
  1947.     }
  1948.     
  1949.     
  1950. /******* Cleanup *******/
  1951.  
  1952. SetFormLength:
  1953. Forward_GXRenderPage:
  1954.     return(anErr);
  1955. }
  1956. /* SD_RenderPage */
  1957.  
  1958.  
  1959. /****************************************************************************************
  1960.  
  1961.                             SD_DefaultPrinter
  1962.                             
  1963.     function:
  1964.                 This routine is called when a new printer object is being created as a
  1965.                 result of someone having called NewJob.  This message gives the driver the
  1966.                 opportunity to add any information we want to the new printer object.  In
  1967.                 this case, we add a new black and white gxViewDevice to the printer object 
  1968.                 which will allow the client application to format a document for this 
  1969.                 specific device at 216 dpi.  If the printer has a color ribbon attachment,
  1970.                 then we create a second view device at 216 dpi which supports eight
  1971.                 colors.
  1972.                 
  1973.     parameters:                
  1974.                 thePrinter        the newly allocated printer object
  1975.                 
  1976.     returns:
  1977.                 OSErr
  1978.                 
  1979. ****************************************************************************************/
  1980. OSErr SD_DefaultPrinter(gxPrinter thePrinter)
  1981. {
  1982.     OSErr             anErr;
  1983.     gxSetColor        theColors[8];
  1984.     gxSetColor        *pColor;
  1985.     
  1986.     // First we let others in the chain default the printer object before we do. 
  1987.  
  1988.     anErr = Forward_GXDefaultPrinter(thePrinter);
  1989.     require(anErr == noErr, Forward_GXDefaultPrinter);
  1990.     
  1991.     // Add the standard black and white view device to the printer object
  1992.     
  1993.     // First set up the color set
  1994.     pColor = &theColors[0];
  1995.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;            // white 
  1996.     pColor++;
  1997.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;            // black 
  1998.     
  1999.     // Now add the view device
  2000.     anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 2);
  2001.     require(anErr == noErr, MakeBWViewDevice);
  2002.     
  2003.     // Does the printer have a color ribbon installed?
  2004.     if ( PrinterHasColorRibbon() )
  2005.     {
  2006.         // Add the standard color view device to the printer object
  2007.         
  2008.         // First set up the color set
  2009.         //
  2010.         //    Color            Index        R                G                B
  2011.         //    white            0            0xFFFF        0xFFFF        0xFFFF        
  2012.         //    yellow            1            0xFFFF        0xFFFF        0x0000
  2013.         //    magenta            2            0xFFFF        0x0000        0xFFFF
  2014.         //    red                3            0xFFFF        0x0000        0x0000
  2015.         //    cyan            4            0x0000        0xFFFF        0xFFFF
  2016.         //    green            5            0x0000        0xFFFF        0x0000
  2017.         //    blue            6            0x0000        0x0000        0xFFFF
  2018.         //    black            7            0x0000        0x0000        0x0000
  2019.  
  2020.         pColor = &theColors[0];
  2021.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;                pColor++;        // white 
  2022.         pColor->rgb.red = pColor->rgb.green = 0xFFFF; pColor->rgb.blue = 0x0000;    pColor++;        // yellow 
  2023.         pColor->rgb.red = pColor->rgb.blue = 0xFFFF; pColor->rgb.green = 0x0000;    pColor++;        // magenta 
  2024.         pColor->rgb.red =0xFFFF;  pColor->rgb.blue = pColor->rgb.green = 0x0000;    pColor++;        // red 
  2025.         pColor->rgb.green = pColor->rgb.blue = 0xFFFF; pColor->rgb.red = 0x0000;    pColor++;        // cyan 
  2026.         pColor->rgb.red = pColor->rgb.blue = 0x0000; pColor->rgb.green = 0xFFFF;    pColor++;        // green 
  2027.         pColor->rgb.red = pColor->rgb.green = 0x0000; pColor->rgb.blue = 0xFFFF;    pColor++;        // blue 
  2028.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;                                    // black 
  2029.         
  2030.         // Now add the view device
  2031.         anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 8);
  2032.         require(anErr == noErr, MakeColorViewDevice);
  2033.     }
  2034.     
  2035. /******* Clean-up *******/
  2036.  
  2037. MakeColorViewDevice:
  2038. MakeBWViewDevice:
  2039. Forward_GXDefaultPrinter:
  2040.     return(anErr);
  2041. }
  2042. /* SD_DefaultPrinter */
  2043.  
  2044. /****************************************************************************************
  2045.  
  2046.                             SD_DefaultFormat
  2047.                             
  2048.     function:
  2049.                 This routine is called when a new format is being created as a result of someone
  2050.                 having called NewFormat.  It is also called to sync up the viewDevices with the
  2051.                 collection's quality mode.
  2052.                 
  2053.     parameters:                
  2054.                 theFormat        the format being defaulted
  2055.                 
  2056.     returns:
  2057.                 OSErr
  2058.                 
  2059. ****************************************************************************************/
  2060. OSErr SD_DefaultFormat(gxFormat theFormat)
  2061. {
  2062.     OSErr    anErr;
  2063.     
  2064.     anErr = Forward_GXDefaultFormat(theFormat);
  2065.     
  2066.     // now, if the application has set up a special formatting mode, we need to update
  2067.     // the quality mode collection item (and any private ones we use)
  2068.     if (anErr == noErr)
  2069.         {
  2070.         gxPoint                    dpiPoint = {ff(72), ff(72)};
  2071.         gxMapping                vdMapping;
  2072.         gxViewDevice            selectedDevice = GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 0);
  2073.         
  2074.         if (selectedDevice != GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 1) )
  2075.             {
  2076.             GXGetViewDeviceMapping(selectedDevice, &vdMapping);
  2077.             MapPoints(&vdMapping, 1, &dpiPoint);
  2078.             
  2079.             {
  2080.             Collection                jobCollection = GXGetJobCollection(GXGetJob());
  2081.             gxQualityInfo            jobQualitySettings;
  2082.             long                    itemSize = sizeof(jobQualitySettings);
  2083.     
  2084.             anErr = GetCollectionItem(GXGetJobCollection(GXGetJob()), 
  2085.                                             gxQualityTag, gxPrintingTagID, 
  2086.                                             &itemSize, &jobQualitySettings);
  2087.             if (anErr == noErr)
  2088.                 {
  2089.                 jobQualitySettings.currentQuality = 
  2090.                     (dpiPoint.y > ff(200)) ? (jobQualitySettings.qualityCount-1) : 0;
  2091.                     
  2092.                 anErr = AddCollectionItem(jobCollection,
  2093.                                             gxQualityTag,
  2094.                                             gxPrintingTagID,
  2095.                                             itemSize,
  2096.                                             &jobQualitySettings);
  2097.                 }
  2098.             }
  2099.             
  2100.             }
  2101.  
  2102.         }
  2103.         
  2104.     return(anErr);
  2105.     
  2106. } 
  2107. /* SD_DefaultFormat */
  2108.  
  2109. /****************************************************************************************
  2110.  
  2111.                             SD_DefaultJob
  2112.                             
  2113.     function:
  2114.                 This routine is called when a new job is being created as a result of someone
  2115.                 having called NewJob.  The driver takes this opportunity to add a default
  2116.                 head motion collection item to the job.
  2117.                 
  2118.     parameters:                
  2119.                 theJob        the job being defaulted
  2120.                 
  2121.     returns:
  2122.                 OSErr
  2123.                 
  2124. ****************************************************************************************/
  2125. OSErr SD_DefaultJob()
  2126. {
  2127.     OSErr        anErr;
  2128.     gxJob         theJob = GXGetJob();
  2129.     
  2130.     // First forward the default job message along
  2131.     anErr = Forward_GXDefaultJob();
  2132.     require(anErr == noErr, Forward_GXDefaultJob);
  2133.     
  2134.     // Add the default collection item which specifies the desired head motion.
  2135.     {
  2136.         HeadMotionJobItem        theMotion;
  2137.         
  2138.         theMotion.direction = doUnidirectional;
  2139.         
  2140.         anErr = AddCollectionItem(    GXGetJobCollection(theJob), 
  2141.                                             kDrvrCreatorType, 
  2142.                                             kHeadMotionItemIndex, 
  2143.                                             sizeof(HeadMotionJobItem),
  2144.                                             &theMotion);
  2145.         check(anErr == noErr);
  2146.     }
  2147.  
  2148.  
  2149. /******* Clean-up *******/
  2150.  
  2151. Forward_GXDefaultJob:
  2152.     return(anErr);
  2153. }
  2154. /* SD_DefaultJob */
  2155.  
  2156.  
  2157. /****************************************************************************************
  2158.  
  2159.                             SD_SetupImageData
  2160.                             
  2161.     function:
  2162.                 This routine is called when the Printing Manager wants us to initialize any
  2163.                 constant data that's used to image the entire job.  This driver takes this
  2164.                 opportunity to massage the raster image data 
  2165.                 
  2166.     parameters:                
  2167.                 hImageData        Handle to the raster imaging data
  2168.     returns:
  2169.                 OSErr
  2170.     
  2171. ****************************************************************************************/
  2172. OSErr SD_SetupImageData(gxRasterImageDataHdl hImageData)
  2173. {
  2174.     OSErr                    anErr;
  2175.     Boolean                 isJobNotFinalQuality;
  2176.     Boolean                    isTextJobFormatMode;
  2177.     gxRasterImageDataPtr    pImageData;
  2178.     HeadMotionJobItem        theMotion;
  2179.     long                    headMotionSize;
  2180.     gxJob                    theJob = GXGetJob();
  2181.  
  2182.     // Let others in the message chain do their SetupImageData function 
  2183.     anErr = Forward_GXSetupImageData(hImageData);
  2184.     require(anErr == noErr, Forward_GXSetupImageData);
  2185.     
  2186.     // Determine if we're to do "final" quality
  2187.     isJobNotFinalQuality = !JobIsBestQuality();
  2188.     
  2189.     // Fetch the head motion job collection item to determine the head motion we should be using
  2190.  
  2191.     headMotionSize = sizeof(HeadMotionJobItem);
  2192.     anErr = GetCollectionItem (GXGetJobCollection(theJob),
  2193.                                         kDrvrCreatorType,
  2194.                                         kHeadMotionItemIndex,
  2195.                                         &headMotionSize,
  2196.                                         &theMotion);
  2197.     check(anErr == noErr);
  2198.     
  2199.     if (anErr != noErr)    //    T => Default to unidirectional printing => better quality
  2200.     {
  2201.         theMotion.direction = doUnidirectional;
  2202.         anErr = noErr;
  2203.     }
  2204.  
  2205.     // Determine if we are to perform draft mode printing
  2206.     isTextJobFormatMode = ( GXGetJobFormatMode(theJob) == gxTextJobFormatMode );
  2207.     
  2208.     // If the job is not final quality or using gxTextJobFormatMode, downgrade the imaging data to lower quality
  2209.     if (isJobNotFinalQuality || isTextJobFormatMode)
  2210.     {
  2211.         pImageData = *hImageData;
  2212.                 
  2213.         // Image at 72 dpi
  2214.         pImageData->hImageRes = ff(72);
  2215.         pImageData->vImageRes = ff(72);
  2216.         
  2217.         // If we're in draft mode, we need to load the draft table to know how to print all possible characters
  2218.         if (isTextJobFormatMode)
  2219.         {
  2220.             Handle                draftTable;
  2221.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2222.         
  2223.             anErr = Send_GXFetchTaggedDriverData('idft', gxPrintingDriverBaseID, &draftTable);
  2224.             require(anErr == noErr, FailedToLoadDraftTable);
  2225.             
  2226.             // Save the draft table handle in our globals
  2227.             (*hGlobals)->draftTable = draftTable;
  2228.         }
  2229.         else    //    T => We need to setup better low resolution halftones
  2230.         {
  2231.             short    plane;
  2232.             
  2233.             // Use halftones that will look better at 72 dpi resolution than our default values.
  2234.             
  2235.             // Use the same angle and frequency for all planes, because gxDispersedDot
  2236.             // won't moire on us
  2237.             for (plane = 0; plane < 4; ++plane)
  2238.             {
  2239.                 pImageData->theSetup.planeSetup[plane].planeHalftone.angle = ff(0);
  2240.                 pImageData->theSetup.planeSetup[plane].planeHalftone.frequency = ff(9);
  2241.                 pImageData->theSetup.planeSetup[plane].planeHalftone.method = gxDispersedDot;
  2242.             }
  2243.         }
  2244.         
  2245.         // Determine the StartSendPage command string to use depending upon whether the user choose birdirectional or
  2246.         // unidirectional motion.
  2247.         
  2248.         if (isJobNotFinalQuality)
  2249.         {
  2250.             // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2251.             // or unidirectional string)
  2252.             
  2253.             if ( theMotion.direction == doUnidirectional )
  2254.                 pImageData->packageControls.startPageStringID = kLowResUniDirID;
  2255.             else
  2256.                 pImageData->packageControls.startPageStringID = kLowResBiDirID;
  2257.         }
  2258.         
  2259.         // Update the packaging data to reflect the lower resolution
  2260.         pImageData->packagingInfo.headHeight         = 8;        // 8 pins (instead of 24)
  2261.         pImageData->packagingInfo.numberPasses     = 1;        // in 1 head pass
  2262.         pImageData->packagingInfo.passOffset         = 0;        // with no space between passes
  2263.     }
  2264.     else    //    T => Final quality job
  2265.     {
  2266.         pImageData = *hImageData;
  2267.                 
  2268.         // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2269.         // or unidirectional string)
  2270.         
  2271.         if ( theMotion.direction == doUnidirectional )
  2272.             pImageData->packageControls.startPageStringID = kHighResUniDirID;
  2273.         else
  2274.             pImageData->packageControls.startPageStringID = kHighResBiDirID;
  2275.  
  2276.         // image at 216 dpi
  2277.         pImageData->hImageRes = ff(216);
  2278.         pImageData->vImageRes = ff(216);
  2279.     }
  2280.     
  2281.     // If the printer doesn't have a color ribbon, set up for black and white printing
  2282.     if ( !PrinterHasColorRibbon() )
  2283.     {
  2284.         pImageData = *hImageData;
  2285.  
  2286.         // one plane, no color flags, move the halftone info up into correct position
  2287.         pImageData->theSetup.planes = 1;
  2288.         pImageData->packagingInfo.colorPasses = 1;
  2289.         pImageData->packagingInfo.packageOptions = 0;
  2290.         pImageData->theSetup.planeSetup[0] = pImageData->theSetup.planeSetup[3];
  2291.         pImageData->theSetup.planeSetup[0].planeHalftone.tinting = gxLuminanceTint;
  2292.         pImageData->theSetup.planeSetup[0].planeHalftone.tintSpace = gxRGBSpace;
  2293.     }
  2294.  
  2295.  
  2296. /******* Clean-up *******/
  2297.  
  2298. FailedToLoadDraftTable:
  2299. Forward_GXSetupImageData:
  2300.     return(anErr);
  2301. }
  2302. /* SD_SetupImageData */
  2303.  
  2304.  
  2305. /****************************************************************************************
  2306.  
  2307.                             SD_FetchTaggedData
  2308.                             
  2309.     function:
  2310.                 This routine is called by the Printing Manager when a resource is fetched
  2311.                 from some resource file.  This driver overrides this message to determine
  2312.                 when someone is fetching the 'cust' resource.  If this resource
  2313.                 is being fetched, and the job we're processing is not best quality, then
  2314.                 we lower the resolution in the 'cust' resource handle returned to be 72 dpi.
  2315.                 This ensures the translation from QuickDraw to QuickDraw GX is done at the
  2316.                 proper resolution.
  2317.                 
  2318.     parameters:    
  2319.                 rsrcType            type of the resource being retrieved
  2320.                 rsrcID            resource ID of the resource being retrieved
  2321.                 theRsrc            handle to the resource retrieved
  2322.                 owner                indicates who is issuing the request; only look at owners == 'drvr'
  2323.                 
  2324.     returns:
  2325.                 OSErr
  2326.  
  2327. ****************************************************************************************/
  2328. OSErr SD_FetchTaggedData(ResType rsrcType, short rsrcID, Handle *theRsrc, OSType owner)
  2329. {
  2330.     OSErr        anErr;
  2331.     
  2332.     if (owner == 'drvr')                                                    //    T => Fetching a driver resource
  2333.     {
  2334.         if (    (rsrcType == gxTrayCountDataType)    &&                    //    T => type is trayCountData
  2335.                 (rsrcID == gxTrayCountDataID)                            //    T => ID is trayCountData
  2336.             )
  2337.         {
  2338.             // Remap as required
  2339.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFeederRsrcID : kDefaultTrayRsrcID);
  2340.         }
  2341.         else if (    (rsrcType == gxTrayNameDataType)    &&            //    T => type is trayName
  2342.                         (rsrcID == kDefaultSheetFdrTray1NameID)    //    T => ID is trayData
  2343.             )
  2344.         {
  2345.             // Remap as required
  2346.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFdrTray1NameID : kDefaultTrayNameID);
  2347.         }
  2348.     }
  2349.     
  2350.     // First fetch the actual resource
  2351.     anErr = Forward_GXFetchTaggedData(rsrcType, rsrcID, theRsrc, owner);
  2352.     require(anErr == noErr, FetchTaggedData);
  2353.     
  2354.     if (    (owner == 'drvr')            &&        //    T => Fetching a driver resource
  2355.             (rsrcType == gxCustType)    &&        //    T => type is 'cust'
  2356.             (rsrcID == gxCustID)        &&        //    T => ID is -8192
  2357.             !JobIsBestQuality()                //    T => Doing rough output
  2358.         )
  2359.     {
  2360.         gxCustomizationHdl    custData;
  2361.         
  2362.         // Change the 'cust' resolution to specify low res translation from QuickDraw to QuickDraw GX
  2363.         (*custData)->horizontalResolution = 72;
  2364.         (*custData)->verticalResolution = 72;
  2365.     }
  2366.  
  2367.  
  2368. /******* Clean-up *******/
  2369.  
  2370. FetchTaggedData:
  2371.     return(anErr);
  2372. }
  2373. /* SD_FetchTaggedData */
  2374.  
  2375.  
  2376. /****************************************************************************************
  2377.  
  2378.                             SD_DefaultDesktopPrinter
  2379.                             
  2380.     function:
  2381.                 This routine is called by the Printing Manager when a new desktop printer is
  2382.                 created.  We take this opportunity to open a connection to the LQ printer to
  2383.                 see how it's configured.  Specifically, we determine if there are trays
  2384.                 attached and if there is a color ribbon installed.  Based upon the device query,
  2385.                 we update the desktop printer file.
  2386.                 
  2387.     parameters:    
  2388.                 printerName        Name of the printer being created
  2389.                 
  2390.     returns:
  2391.                 OSErr
  2392.  
  2393. ****************************************************************************************/
  2394. OSErr SD_DefaultDesktopPrinter(Str31 printerName)
  2395. {
  2396.     OSErr        anErr;
  2397.     
  2398.     // First let the Printing Manager create the desktop printer
  2399.     anErr = Forward_GXDefaultDesktopPrinter(printerName);
  2400.     require(anErr == noErr, DefaultDesktopPrinter);
  2401.     
  2402.     // Optional step (now removed): during creation of the printer we could open a connection
  2403.     // to get the current configuration.  However, this has the disadvantage of making the user
  2404.     // wait until the printer is available.  The user can force a configuration update by printing
  2405.     // any document to the printer (even a blank one)
  2406.     
  2407.     // Now we attempt to open a connection to the device (it will update the config. file)
  2408. //    anErr = Send_GXOpenConnection();
  2409. //    require(anErr == noErr, OpenConnection);
  2410.     
  2411.     // A side effect of opening the connection will be that we will have already updated
  2412.     // the configuration information (in the file) that specifies whether a color ribbon
  2413.     // is installed and the number of sheet feeder trays attached (if any). ## The only additional
  2414.     // thing we'd want to do here is to update the number of trays specified in the desktop
  2415.     // printer file to be the actual number of trays attached to the device.  Currently, the 
  2416.     // system assumes the number of trays attached is equivalent to the number of default
  2417.     // trays specified in our driver resources.  Though we can query the printer for the 
  2418.     // exact number of trays, we cannot update the info. in the config. file that specifies
  2419.     // the exact number of trays.  We need a RemoveTrayInfo routine.
  2420.     
  2421.     // Now we just close down the connection
  2422. //    anErr = Send_GXCloseConnection();
  2423. //    check(anErr == noErr);
  2424.  
  2425.     
  2426. /******* Clean-up *******/
  2427.  
  2428. OpenConnection:
  2429. DefaultDesktopPrinter:
  2430.     return(anErr);
  2431. }
  2432. /* SD_DefaultDesktopPrinter */
  2433.  
  2434.  
  2435. /****************************************************************************************
  2436.  
  2437.                             SD_GetDTPMenuList
  2438.                             
  2439.     function:
  2440.                 NOOP.
  2441.                 
  2442.     parameters:    
  2443.                 hMenu            Handle to the menu that's being built
  2444.                 
  2445.     returns:
  2446.                 OSErr
  2447.  
  2448. ****************************************************************************************/
  2449. OSErr SD_GetDTPMenuList(MenuHandle hMenu)
  2450. {
  2451.     return(Forward_GXGetDTPMenuList(hMenu));
  2452. }
  2453. /* SD_GetDTPMenuList */
  2454.  
  2455.  
  2456. /****************************************************************************************
  2457.  
  2458.                             SD_DTPMenuSelect
  2459.                             
  2460.     function:
  2461.                 This routine is called by the Printing Manager when a menu item in the Finder's
  2462.                 gxPrinter menu is selected.  This routine determines if the menu item selected
  2463.                 is the "Input Tray…" item. If it's, then display the dialog which lets the user
  2464.                 specify the paper in the LQ's sheet feeder if we know there are some trays
  2465.                 attached to the printer.  Otherwise, we just pass the item on to others in the chain.
  2466.                 
  2467.     parameters:    
  2468.                 itemNum        Menu item number that was selected    
  2469.                 
  2470.     returns:
  2471.                 OSErr
  2472.  
  2473. ****************************************************************************************/
  2474. OSErr SD_DTPMenuSelect(short itemNum)
  2475. {
  2476.     OSErr        anErr;
  2477.     
  2478.     if ((itemNum == gxInputTraysMenuItem) && (PrinterHasTrays() > 0))    //    T => User wants to configure the input trays
  2479.     {
  2480.         anErr = DoSheetfeederDialog();
  2481.     }
  2482.     else    //    T => We didn't process the item
  2483.     {
  2484.         // Pass the message on to others in the chain
  2485.         anErr = Forward_GXDTPMenuSelect(itemNum);
  2486.     }
  2487.     
  2488.     check(anErr == noErr);
  2489.  
  2490.     return(anErr);
  2491. }
  2492. /* SD_DTPMenuSelect */
  2493.  
  2494.  
  2495. /****************************************************************************************
  2496.  
  2497.                             SD_RasterPackageBitmap
  2498.                             
  2499.     function:
  2500.                 This routine is called by the Printing Manager when it has completed rendering
  2501.                 a single portion of a raster page and the driver should now package the data
  2502.                 and output it to the device.  This routine is called to package one complete band.
  2503.                 
  2504.                 It routine does the following:
  2505.                     
  2506.                 1)    Starts filling the buffer from buffer + bufferPos.  Remember
  2507.                     that this pointer may not be word aligned - so be careful
  2508.                     assigning things into it.
  2509.                     
  2510.                 2)    Puts a "fake" set of set margins commands at
  2511.                     the begining of the data.  Since most of the time we don't
  2512.                     know the margins, we save away the value of the bufferPos,
  2513.                     and backpatch it after we have finished with the gxBitmap.
  2514.                     
  2515.                 3)    Adds in the rotated data for your printer.  The data to stuff starts
  2516.                     at location pPackage->startRaster * pPackage->bitmapToPackage->rowBytes (startY)
  2517.                     in the pPackage->bitmapToPackage gxBitmap.  Stuffs the bits from here until
  2518.                     we reach startY + <the band size>, which is the size of our single
  2519.                     band in this resolution mode.  Increment our number by 
  2520.                     <your pass offset> + 1, which is the number of microspaces
  2521.                     we will send between head passes to form this band.   Take care
  2522.                     that we don't step off of the end of the gxBitmap in this operation,
  2523.                     since we may be called with startY at the end of the offscreen if the first part
  2524.                     of the band is white.
  2525.                     
  2526.                     colorBand contains the color band which we should be stuffing, from
  2527.                     1 to the number of color passes our printer needs (4).
  2528.                     Packs in the correct color band.  The packager will call us once
  2529.                     for each color band, and correctly handle line feeds and backward
  2530.                     line feeds to do the correct thing.  If your printer takes full
  2531.                     RGB or CYMK data, define your number of colors to be
  2532.                     1 and pack the full RGB or CYMK data with the one call.
  2533.                     
  2534.                     If you request kSendAllColors in your raster pack resource, then this
  2535.                     message will always be called for all color passes, even those that
  2536.                     do not have data on them.  For some printers, this is useful.  For the
  2537.                     case of the ImageWriter, this option is not specified, so this message
  2538.                     will only be sent for colors that actually have dirty bits within them.
  2539.                     
  2540.                 4)    Backpatches SetMargins from the saved value in step 2) now that we
  2541.                     know the margins.
  2542.                     
  2543.                 5)    Increments bufferPos by the number of bytes we have
  2544.                     added to the buffer.  Be sure to take into account the Set Margins
  2545.                     command.
  2546.  
  2547.     parameters:        
  2548.                 whatToPackage        info. about the gxBitmap whose data is to be sent to the printer
  2549.                 buffer                buffer in which to place the packaged data
  2550.                 bufferPos            position within buffer of where to place the packaged data
  2551.                 imageData            handle to the raster image data info.
  2552.                 
  2553.     returns:
  2554.                 OSErr
  2555.  
  2556. ****************************************************************************************/
  2557. OSErr SD_RasterPackageBitmap(    gxRasterPackageBitmapRec    *whatToPackage, 
  2558.                                 Ptr                         buffer,
  2559.                                 unsigned long                 *bufferPos, 
  2560.                                 gxRasterImageDataHdl        imageData)
  2561. {
  2562.     OSErr                anErr = noErr;
  2563.     ScanLinePtr            pTheScanLine;            // Pointer to the start of scan line data
  2564.     unsigned short        firstDirty;                // First dirty pixel
  2565.     Boolean                bandIsDirty;            // Is this band dirty?
  2566.     unsigned short        whichCol;                // Index into the scan line data of where to place the next data bytes
  2567.     unsigned short        x;                            
  2568.     unsigned long        tempColumn;                // Placeholder for the column of data we're currently assembling
  2569.                                                         //    for 72 dpi:     only high order byte is used
  2570.                                                         //    for 216 dpi:    highest order three bytes are used
  2571.     Ptr                    basePtr;                    // Pointer to current X byte
  2572.     unsigned char        outputMask;                // Mask of bit to set in rotated image
  2573.     unsigned char        inputMask;                // Mask of bit to look at in X
  2574.     unsigned short        yPointerOffset;        // Increment pointer by this to get to next scanline
  2575.     unsigned short        endY;                        //    Last scan line to examine (top-to-bottom)
  2576.     unsigned short        endX;                        //    Last pixel column to examine (left-to-right)
  2577.     unsigned short        incrY;                    //    Number of scan lines to increment by when advancing to the next scan line
  2578.     short                bytesPerBand;            //    Number of bytes in a single band (1 for 72 dpi, 3 for 216 dpi)
  2579.             
  2580.  
  2581.     // Determine the number of bytes that are in a single band 
  2582.     if ( (*imageData)->hImageRes == ff(72) )    //    T => Low resolution output
  2583.         bytesPerBand = 1;
  2584.     else
  2585.         bytesPerBand = 3;
  2586.     
  2587.     //    Overlay a scan line structure on the buffer we're filling in 
  2588.     pTheScanLine = (ScanLinePtr) (buffer + *bufferPos);
  2589.     
  2590.     // Set color mode for this scan line, if needed 
  2591.     
  2592.     pTheScanLine->cColorEscape = kEscape;
  2593.     pTheScanLine->cSetColorCommand = kSetColorCommand;
  2594.     
  2595.     if ( (*imageData)->packagingInfo.colorPasses == 4 )    //    T => Doing four pass color output
  2596.     {
  2597.         switch (whatToPackage->colorBand)    //    Determine which color to select
  2598.         {
  2599.             case 1: // yellow
  2600.                 pTheScanLine->cColor    = '1';
  2601.                 break;
  2602.                 
  2603.             case 2: // magenta
  2604.                 pTheScanLine->cColor    = '2';
  2605.                 break;
  2606.  
  2607.             case 3: // cyan
  2608.                 pTheScanLine->cColor    = '3';
  2609.                 break;
  2610.                 
  2611.             case 4: // black
  2612.                 pTheScanLine->cColor    = '0';
  2613.                 break;
  2614.         }
  2615.     }
  2616.     else    //    T => Just doing black and white printing; select the color black
  2617.         pTheScanLine->cColor = '0';
  2618.  
  2619.     // We start out with no dirty bits
  2620.     firstDirty = 0;
  2621.     bandIsDirty = false;
  2622.     
  2623.     // Set our array index to zero
  2624.     whichCol = 0;
  2625.     
  2626.     // Get the byte pointer for the start of this color band
  2627.     basePtr = whatToPackage->bitmapToPackage->image;
  2628.     
  2629.     // Get the byte pointer for the start of the first scan line
  2630.     basePtr += whatToPackage->startRaster * whatToPackage->bitmapToPackage->rowBytes;
  2631.             
  2632.     // Save away loop invariants
  2633.     
  2634.     endY = whatToPackage->startRaster + (*imageData)->packagingInfo.headHeight;    // Ending Y scan line
  2635.     incrY = (*imageData)->packagingInfo.passOffset + 1;                                    // Number of scanlines to increment by
  2636.     endX = whatToPackage->dirtyRect.right;                                                        // Ending X pos
  2637.     yPointerOffset = incrY * whatToPackage->bitmapToPackage->rowBytes;                // amount to add to the input pointer to move to the next scanline
  2638.  
  2639.     // If the ending position is too large for the gxBitmap we have been given,
  2640.     //truncate it, so that we don't print garbage
  2641.  
  2642.     if (endY > whatToPackage->bitmapToPackage->height)
  2643.          endY = whatToPackage->bitmapToPackage->height;
  2644.     
  2645.     // Start with the first bit in the byte sub-band
  2646.     inputMask = 0x80;
  2647.  
  2648.     // For the entire width of the scan line, move a rolling mask along in the
  2649.     // X direction, rotating up 8 or 24 bits of Y data per column.
  2650.     
  2651.     for (x = 0; x < endX; x++)
  2652.     {        
  2653.         Ptr    thePtr;
  2654.  
  2655.         // The bits in this column are clear to begin with
  2656.         tempColumn = 0;
  2657.         
  2658.         // Which byte(s) to look at in the input buffer
  2659.         thePtr = basePtr;
  2660.         
  2661.         // For the number of bytes in a single band, scan through each single  
  2662.         // byte sub-band, setting each of the 8 bits = the bit in that scan line
  2663.         {
  2664.             short                bitsPerByte;
  2665.             short                byteSubBand = bytesPerBand;
  2666.             unsigned char        *currByte = (unsigned char *) &tempColumn;
  2667.             short                currYPos;
  2668.             
  2669.             currYPos = whatToPackage->startRaster;
  2670.             
  2671.             do
  2672.             {
  2673.                 // Where to place the bit in the output. The LQ takes the bit pattern upside down.
  2674.                 outputMask = 0x01;
  2675.         
  2676.                 bitsPerByte = 8;
  2677.                 while ( (bitsPerByte > 0) && (currYPos < endY) )
  2678.                 {
  2679.                     // If we have a bit turned on in the input, rotate it into the output
  2680.                     if ( ((*thePtr) & inputMask) != 0 )
  2681.                         *currByte |= outputMask;
  2682.         
  2683.                     // move onto next position in the output data                
  2684.                     outputMask <<= 1;
  2685.                     
  2686.                     // move onto the next scan line in the input data
  2687.                     thePtr += yPointerOffset;
  2688.                     
  2689.                     // Indicate we processed one of the bits
  2690.                     bitsPerByte--;
  2691.                     
  2692.                     // Keep track of our Y position as we move down the column
  2693.                     currYPos += incrY;
  2694.                 }
  2695.                 
  2696.                 if (currYPos >= endY)    //    T => We're done with this column
  2697.                     break;
  2698.                     
  2699.                 // Indicate we processed one of the byte rows in the band
  2700.                 byteSubBand--;
  2701.                 
  2702.                 // Bump to the next byte to fill in tempColumn
  2703.                 currByte++;
  2704.             }
  2705.             while (byteSubBand > 0);
  2706.         }
  2707.             
  2708.         // Save the column info (a max. of three bytes). Note: we'll only advance whichCol based upon the number of bytes per band
  2709.         BlockMove((Ptr) &tempColumn, (Ptr) &(pTheScanLine->iTheData[whichCol]), 3);
  2710.         
  2711.         // If we have some form of data, then mark that this band is dirty
  2712.         if (tempColumn != 0)
  2713.         {
  2714.             if (!bandIsDirty)    //    T => Not already dirty; remember the first dirty pixel
  2715.             {
  2716.                 /* These are the first dirty pixels we have seen so far */
  2717.                 bandIsDirty = true;
  2718.                 firstDirty = x;
  2719.             }
  2720.         }
  2721.             
  2722.         // If we have some dirty bits, adjust the whichCol variable based upon the number of bytes in a band
  2723.         if (bandIsDirty)
  2724.         {
  2725.             // Move on to the next column or set of columns
  2726.             whichCol += bytesPerBand;
  2727.         }
  2728.  
  2729.         // Position for the next bit in the input byte currently referenced by basePtr
  2730.         inputMask >>= 1;
  2731.         
  2732.         if (inputMask == 0)    //    T => Need to reset the input mask and advance the pointer
  2733.         {
  2734.             // Get the next byte
  2735.             basePtr++;
  2736.             
  2737.             // Reset the bit mask to the first bit
  2738.             inputMask = 0x80;
  2739.         }
  2740.     } // end of loop for width of gxBitmap
  2741.  
  2742.     // If we have a dirty band, fill in the left margin setting and add a carriage return to the end
  2743.     if (bandIsDirty)
  2744.     {            
  2745.         // Set the left margin to be the first dirty pixel in the scan line
  2746.         {
  2747.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2748.             
  2749.             check(hGlobals);
  2750.             
  2751.             // Stuff in the set margin command
  2752.             
  2753.             pTheScanLine->cMarginsEscape = kEscape;
  2754.             pTheScanLine->cMarginsCommand = (bytesPerBand == 1) ? kLowResMarginsCommand : kHighResMarginsCommand;
  2755.             
  2756.             // Convert left margin into ASCII and place it at the start of the scan line
  2757.             Long2Dec((*hGlobals)->leftMargin + firstDirty, (Ptr) (pTheScanLine->cIndentDistance));
  2758.         }
  2759.         
  2760.         // Now fill in the last escape sequence command depending upon if we're doing low-res or high-res graphics
  2761.         
  2762.         pTheScanLine->cEscape = kEscape;
  2763.         pTheScanLine->cCommand = (bytesPerBand == 1)    ? kLowResGraphicsCommand : kHighResGraphicsCommand;
  2764.  
  2765.         // If we're doing high-res, then whichCol must be divided by three to compensate for the 3-byte buffer entries
  2766.         {
  2767.             short        adjustedWhichCol = whichCol;
  2768.             
  2769.             if (bytesPerBand == 3)
  2770.                 adjustedWhichCol /= 3;
  2771.                 
  2772.             Long2Dec(adjustedWhichCol, (Ptr) (pTheScanLine->cLineLength));
  2773.         }
  2774.         
  2775.         
  2776.         //    Increment the count of the number of bytes that have been added to the buffer
  2777.         *bufferPos += kScanLineHdrSize + whichCol;
  2778.  
  2779.         // Lastly, put a <cr> at the end of the line
  2780.         *(buffer + *bufferPos) = '\n';
  2781.         *bufferPos += 1;
  2782.     }
  2783.         
  2784.     return(anErr);
  2785. }
  2786. /* SD_RasterPackageBitmap */
  2787.  
  2788.  
  2789. /****************************************************************************************
  2790.  
  2791.                             SD_RasterLineFeed
  2792.                             
  2793.     function:
  2794.                 This routine is called by the Printing Manager to send the appropriate line
  2795.                 feed commands to the printer i norder to skip up or down the page the 
  2796.                 equivalent of lineFeedSize pixels.
  2797.                 
  2798.     parameters:    
  2799.                 lineFeedSize    number of pixels to line feed by
  2800.                 buffer            buffer in which to place the linefeed packaging commands
  2801.                 bufferPos        offset within buffer at which to place the linefeed commands
  2802.                 imageData        handle to the raster image data
  2803.                 
  2804.     returns:
  2805.                 OSErr
  2806.  
  2807. ****************************************************************************************/
  2808. OSErr SD_RasterLineFeed(short                     *lineFeedSize, 
  2809.                         Ptr                         buffer, 
  2810.                         unsigned long            *bufferPos, 
  2811.                         gxRasterImageDataHdl    imageData)
  2812. {
  2813.     OSErr        anErr = noErr;
  2814.     
  2815.     // If there is no need for any line feeds, then just return now
  2816.     if (*lineFeedSize == 0)
  2817.         return(anErr);
  2818.         
  2819.     // If we are in low res mode, we double the line feed size, as all ImageWriter LQ 
  2820.     // line feed commands are expressed at 144 dpi.
  2821.     if ( (*imageData)->vImageRes == ff(72) )
  2822.     {
  2823.         *lineFeedSize <<= 1;
  2824.         
  2825.         // do the line feed in the default way
  2826.         anErr = Forward_GXRasterLineFeed(lineFeedSize, buffer, bufferPos, imageData);
  2827.  
  2828.         *lineFeedSize >>= 1;
  2829.     }
  2830.     else    //    T => In high res. mode; must determine the number of 1/144 inch and 1/216 inch line feeds needed
  2831.     {
  2832.         Ptr        nextByte;    
  2833.         fixed        lineFeedInInches;
  2834.         fixed        oneOver144;
  2835.         fixed        remainder;
  2836.         short        num216FractLineFeeds;
  2837.         fixed        num144FractLineFeeds;
  2838.         Str31        aNumber;
  2839.                         
  2840.         // Determine the location at which we'll begin inserting commands
  2841.         nextByte = buffer + *bufferPos;
  2842.         
  2843.         // Is line feed movement going to be backward?
  2844.         if ( *lineFeedSize < 0 )
  2845.         {
  2846.             *lineFeedSize = -(*lineFeedSize);    // Force positive
  2847.             
  2848.             // Add the backward direction command to the buffer
  2849.             *nextByte++ = kEscape;
  2850.             *nextByte++ = 'r';
  2851.         }
  2852.         else    //    T => Paper motion is forward
  2853.         {
  2854.             // Add the forward direction command to the buffer
  2855.             *nextByte++ = kEscape;
  2856.             *nextByte++ = 'f';
  2857.         }
  2858.         
  2859.         // Update the count of the number of bytes added to the buffer
  2860.         *bufferPos += 2;
  2861.         
  2862.         // Determine the number of inches we need to skip with the line feed command
  2863.         lineFeedInInches = FixDiv( IntToFixed(*lineFeedSize), ff(216) );
  2864.         
  2865.         // Determine the integral number of 1/144 inch increments the line feed space comprises
  2866.         
  2867.         oneOver144 = FixDiv(ff(1), ff(144));
  2868.         num144FractLineFeeds = FixDiv( lineFeedInInches, oneOver144 );
  2869.         
  2870.         // Determine the remaining 1/216 inch line feeds we'll need to add to the buffer
  2871.         
  2872.         remainder = lineFeedInInches - FixMul( IntToFixed( FixedToInt(num144FractLineFeeds) ), oneOver144 );
  2873.         num216FractLineFeeds = FixedToInt( FixDiv( remainder, FixDiv( ff(1), ff(216) ) ) );
  2874.         
  2875.         // Send the line feed spacing commands and the line feeds necessary for the 1/144th's portion of the movement
  2876.         {
  2877.             short        numOne144ths = FixedToInt(num144FractLineFeeds);
  2878.             
  2879.             if (numOne144ths >= 99)    //    T => We can do a max. of 99/144 inch movement at a time
  2880.             {
  2881.                 //    Add the line feed spacing command to the buffer
  2882.                 *nextByte++ = kEscape;
  2883.                 *nextByte++ = 'T';
  2884.                 *nextByte++ = '9';
  2885.                 *nextByte++ = '9';
  2886.                 
  2887.                 // Update the count of the number of bytes added to the buffer
  2888.                 *bufferPos += 4;
  2889.         
  2890.                 do
  2891.                 {
  2892.                     *nextByte++ = kLineFeed;        // line feed
  2893.                     
  2894.                     // Update the count of the number of bytes added to the buffer
  2895.                     *bufferPos += 1;
  2896.         
  2897.                     numOne144ths -= 99;
  2898.                 }
  2899.                 while (numOne144ths >= 99);
  2900.             }
  2901.                 
  2902.             // Send remaining line feeds to finish off the 1/144th's portion of the movement
  2903.  
  2904.             if (numOne144ths > 0)    //    T => Still more movement
  2905.             {
  2906.                 *nextByte++ = kEscape;
  2907.                 *nextByte++ = 'T';
  2908.                 
  2909.                 NumToString(numOne144ths, aNumber);
  2910.                 if ( Length(aNumber) == 1 )
  2911.                 {
  2912.                     *nextByte++ = '0';
  2913.                     *nextByte++ = aNumber[1];
  2914.                 }
  2915.                 else
  2916.                 {
  2917.                     *nextByte++ = aNumber[1];
  2918.                     *nextByte++ = aNumber[2];
  2919.                 }
  2920.                 
  2921.                 // Add the linefeed character
  2922.                 *nextByte++ = kLineFeed;
  2923.  
  2924.                 // Update the count of the number of bytes added to the buffer
  2925.                 *bufferPos += 5;
  2926.             }
  2927.         }
  2928.         
  2929.         // Now send any spacing command for the remaining 1/216th portion of the movement if needed
  2930.         if (num216FractLineFeeds > 0)
  2931.         {
  2932.             NumToString(num216FractLineFeeds, aNumber);
  2933.             
  2934.             // Add the command to the buffer: <Esc> t <num line feeds>
  2935.             
  2936.             *nextByte++ = kEscape;
  2937.             *nextByte++ = 't';
  2938.             *nextByte = aNumber[1];
  2939.             
  2940.             // Bump the buffer byte count to account for these new characters
  2941.             *bufferPos += 3;
  2942.         }
  2943.  
  2944.         // We always handle the entire linefeed request so we can zero lineFeedSize
  2945.         *lineFeedSize = 0;
  2946.     }
  2947.  
  2948.     return(anErr);
  2949. }
  2950. /* SD_RasterLineFeed */
  2951.  
  2952.  
  2953.